Changeset 69210 in webkit


Ignore:
Timestamp:
Oct 6, 2010 10:31:40 AM (14 years ago)
Author:
weinig@apple.com
Message:

Generate the messages sent to the WebPageProxy
​https://bugs.webkit.org/show_bug.cgi?id=47239

Reviewed by Adam Roben.

  • Platform/CoreIPC/Arguments.h:

Add additional typedefs.

  • Platform/CoreIPC/HandleMessage.h:

(CoreIPC::handleMessage):
Add more handleMessage implementations.

  • Scripts/webkit2/messages.py:
  • Scripts/webkit2/messages_unittest.py:

Add headers for reply argument types.

  • Shared/CoreIPCSupport/WebPageProxyMessageKinds.h: Removed.
  • Shared/StringPairVector.h: Added.

This file is a hack to work around a deficiency in the generator
which can't deal with class templates with more than one argument.

  • UIProcess/API/mac/PageClientImpl.h:
  • UIProcess/API/mac/PageClientImpl.mm:
  • UIProcess/API/qt/qwkpage.cpp:
  • UIProcess/API/qt/qwkpage_p.h:
  • UIProcess/PageClient.h:
  • UIProcess/WebEditCommandProxy.cpp:
  • UIProcess/WebFormClient.cpp:
  • UIProcess/WebFormClient.h:
  • UIProcess/WebPageProxy.cpp:
  • UIProcess/WebPageProxy.h:
  • WebProcess/WebCoreSupport/WebChromeClient.cpp:
  • WebProcess/WebCoreSupport/WebEditorClient.cpp:
  • WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp:
  • WebProcess/WebPage/WebBackForwardListProxy.cpp:
  • WebProcess/WebPage/WebPage.cpp:

Migrate to generated calls.

  • UIProcess/WebPageProxy.messages.in: Added.

New messages definitions file.

  • DerivedSources.make:
  • DerivedSources.pro:
  • win/WebKit2.vcproj:
  • WebKit2.pro:
  • WebKit2.xcodeproj/project.pbxproj:

Add new files.

Location:
trunk/WebKit2
Files:
2 added
1 deleted
27 edited

Legend:

Unmodified
Added
Removed

  • trunk/WebKit2/ChangeLog

    r69155 r69210  
     12010-10-06  Sam Weinig  <sam@webkit.org>
     2
     3        Reviewed by Adam Roben.
     4
     5        Generate the messages sent to the WebPageProxy
     6        https://bugs.webkit.org/show_bug.cgi?id=47239
     7
     8        * Platform/CoreIPC/Arguments.h:
     9        Add additional typedefs.
     10
     11        * Platform/CoreIPC/HandleMessage.h:
     12        (CoreIPC::handleMessage):
     13        Add more handleMessage implementations.
     14
     15        * Scripts/webkit2/messages.py:
     16        * Scripts/webkit2/messages_unittest.py:
     17        Add headers for reply argument types.
     18
     19        * Shared/CoreIPCSupport/WebPageProxyMessageKinds.h: Removed.
     20
     21        * Shared/StringPairVector.h: Added.
     22        This file is a hack to work around a deficiency in the generator
     23        which can't deal with class templates with more than one argument.
     24
     25        * UIProcess/API/mac/PageClientImpl.h:
     26        * UIProcess/API/mac/PageClientImpl.mm:
     27        * UIProcess/API/qt/qwkpage.cpp:
     28        * UIProcess/API/qt/qwkpage_p.h:
     29        * UIProcess/PageClient.h:
     30        * UIProcess/WebEditCommandProxy.cpp:
     31        * UIProcess/WebFormClient.cpp:
     32        * UIProcess/WebFormClient.h:
     33        * UIProcess/WebPageProxy.cpp:
     34        * UIProcess/WebPageProxy.h:
     35        * WebProcess/WebCoreSupport/WebChromeClient.cpp:
     36        * WebProcess/WebCoreSupport/WebEditorClient.cpp:
     37        * WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp:
     38        * WebProcess/WebPage/WebBackForwardListProxy.cpp:
     39        * WebProcess/WebPage/WebPage.cpp:
     40        Migrate to generated calls.
     41
     42        * UIProcess/WebPageProxy.messages.in: Added.
     43        New messages definitions file.
     44
     45        * DerivedSources.make:
     46        * DerivedSources.pro:
     47        * win/WebKit2.vcproj:
     48        * WebKit2.pro:
     49        * WebKit2.xcodeproj/project.pbxproj:
     50        Add new files.
     51
    1522010-10-05  Anders Carlsson  <andersca@apple.com>
    253

  • trunk/WebKit2/DerivedSources.make

    r69029 r69210  
    44    $(WebKit2)/WebProcess/WebPage \
    55    $(WebKit2)/WebProcess \
     6    $(WebKit2)/UIProcess \
    67    $(WebKit2)/UIProcess/Plugins \
    78#
    … …  
    1314    PluginProxy \
    1415    WebPage \
     16    WebPageProxy \
    1517    WebProcess \
    1618    WebProcessConnection \

  • trunk/WebKit2/DerivedSources.pro

    r69046 r69210  
    5353QMAKE_EXTRA_TARGETS                += messagereceiver_generator
    5454
     55processmessageheader_generator.commands = python $${SRC_ROOT_DIR}/WebKit2/Scripts/generate-messages-header.py  $${SRC_ROOT_DIR}/WebKit2/UIProcess/WebPageProxy.messages.in > $$OUTPUT_DIR/WebKit2/generated/WebPageProxyMessages.h
     56processmessageheader_generator.depends  = $${SRC_ROOT_DIR}/WebKit2/Scripts/generate-messages-header.py $${SRC_ROOT_DIR}/UIProcess/WebPageProxy/WebProcess.messages.in
     57processmessageheader_generator.target   = $${OUTPUT_DIR}/WebKit2/generated/WebPageProxyMessages.h
     58generated_files.depends                 += processmessageheader_generator
     59QMAKE_EXTRA_TARGETS                     += processmessageheader_generator
     60
     61processmessagereceiver_generator.commands = python $${SRC_ROOT_DIR}/WebKit2/Scripts/generate-message-receiver.py  $${SRC_ROOT_DIR}/WebKit2/UIProcess/WebPageProxy.messages.in > $$OUTPUT_DIR/WebKit2/generated/WebPageProxyMessageReceiver.cpp
     62processmessagereceiver_generator.depends  = $${SRC_ROOT_DIR}/WebKit2/Scripts/generate-message-receiver.py $${SRC_ROOT_DIR}/WebKit2/UIProcess/WebPageProxy.messages.in
     63processmessagereceiver_generator.target   = $${OUTPUT_DIR}/WebKit2/generated/WebPageProxyMessageReceiver.cpp
     64generated_files.depends                   += processmessagereceiver_generator
     65QMAKE_EXTRA_TARGETS                       += processmessagereceiver_generator
     66
    5567processmessageheader_generator.commands = python $${SRC_ROOT_DIR}/WebKit2/Scripts/generate-messages-header.py  $${SRC_ROOT_DIR}/WebKit2/WebProcess/WebProcess.messages.in > $$OUTPUT_DIR/WebKit2/generated/WebProcessMessages.h
    5668processmessageheader_generator.depends  = $${SRC_ROOT_DIR}/WebKit2/Scripts/generate-messages-header.py $${SRC_ROOT_DIR}/WebKit2/WebProcess/WebProcess.messages.in

  • trunk/WebKit2/Platform/CoreIPC/Arguments.h

    r68989 r69210  
    209209template<typename T1, typename T2, typename T3, typename T4, typename T5> class Arguments5 : Arguments4<T1, T2, T3, T4> {
    210210public:
     211    typedef T1 FirstArgumentType;
     212    typedef T2 SecondArgumentType;
     213    typedef T3 ThirdArgumentType;
     214    typedef T4 FourthArgumentType;
     215    typedef T5 FifthArgumentType;
     216
    211217    Arguments5(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5)
    212218        : Arguments4<T1, T2, T3, T4>(t1, t2, t3, t4)

  • trunk/WebKit2/Platform/CoreIPC/HandleMessage.h

    r68989 r69210  
     1/*
     2 * Copyright (C) 2010 Apple Inc. All rights reserved.
     3 *
     4 * Redistribution and use in source and binary forms, with or without
     5 * modification, are permitted provided that the following conditions
     6 * are met:
     7 * 1. Redistributions of source code must retain the above copyright
     8 *    notice, this list of conditions and the following disclaimer.
     9 * 2. Redistributions in binary form must reproduce the above copyright
     10 *    notice, this list of conditions and the following disclaimer in the
     11 *    documentation and/or other materials provided with the distribution.
     12 *
     13 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
     14 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
     15 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     16 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
     17 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     18 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     19 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     20 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     21 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     22 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
     23 * THE POSSIBILITY OF SUCH DAMAGE.
     24 */
     25
    126#ifndef HandleMessage_h
    227#define HandleMessage_h
    … …  
    2247}
    2348
     49template<typename T, typename C>
     50void handleMessage(ArgumentDecoder* arguments, C* object, void (C::*function)(CoreIPC::ArgumentDecoder*))
     51{
     52    (object->*function)(arguments);
     53}
     54
    2455template<typename T, typename C, typename P1, typename P2>
    2556void handleMessage(ArgumentDecoder* arguments, C* object, void (C::*function)(P1, P2))
    … …  
    3465}
    3566
     67template<typename T, typename C, typename P1>
     68void handleMessage(ArgumentDecoder* arguments, C* object, void (C::*function)(P1, CoreIPC::ArgumentDecoder*))
     69{
     70    typename RemoveReference<typename T::FirstArgumentType>::Type firstArgument;
     71    if (!arguments->decode(firstArgument))
     72        return;
     73    (object->*function)(firstArgument, arguments);
     74}
     75
    3676template<typename T, typename C, typename P1, typename P2, typename P3>
    3777void handleMessage(ArgumentDecoder* arguments, C* object, void (C::*function)(P1, P2, P3))
    … …  
    4989}
    5090
     91template<typename T, typename C, typename P1, typename P2>
     92void handleMessage(ArgumentDecoder* arguments, C* object, void (C::*function)(P1, P2, CoreIPC::ArgumentDecoder*))
     93{
     94    typename RemoveReference<typename T::FirstArgumentType>::Type firstArgument;
     95    if (!arguments->decode(firstArgument))
     96        return;
     97    typename RemoveReference<typename T::SecondArgumentType>::Type secondArgument;
     98    if (!arguments->decode(secondArgument))
     99        return;
     100    (object->*function)(firstArgument, secondArgument, arguments);
     101}
     102
     103template<typename T, typename C, typename P1, typename P2, typename P3, typename P4>
     104void handleMessage(ArgumentDecoder* arguments, C* object, void (C::*function)(P1, P2, P3, P4))
     105{
     106    typename RemoveReference<typename T::FirstArgumentType>::Type firstArgument;
     107    if (!arguments->decode(firstArgument))
     108        return;
     109    typename RemoveReference<typename T::SecondArgumentType>::Type secondArgument;
     110    if (!arguments->decode(secondArgument))
     111        return;
     112    typename RemoveReference<typename T::ThirdArgumentType>::Type thirdArgument;
     113    if (!arguments->decode(thirdArgument))
     114        return;
     115    typename RemoveReference<typename T::FourthArgumentType>::Type fourthArgument;
     116    if (!arguments->decode(fourthArgument))
     117        return;
     118    (object->*function)(firstArgument, secondArgument, thirdArgument, fourthArgument);
     119}
     120
     121template<typename T, typename C, typename P1, typename P2, typename P3>
     122void handleMessage(ArgumentDecoder* arguments, C* object, void (C::*function)(P1, P2, P3, CoreIPC::ArgumentDecoder*))
     123{
     124    typename RemoveReference<typename T::FirstArgumentType>::Type firstArgument;
     125    if (!arguments->decode(firstArgument))
     126        return;
     127    typename RemoveReference<typename T::SecondArgumentType>::Type secondArgument;
     128    if (!arguments->decode(secondArgument))
     129        return;
     130    typename RemoveReference<typename T::ThirdArgumentType>::Type thirdArgument;
     131    if (!arguments->decode(thirdArgument))
     132        return;
     133    (object->*function)(firstArgument, secondArgument, thirdArgument, arguments);
     134}
     135
     136template<typename T, typename C, typename P1, typename P2, typename P3, typename P4, typename P5>
     137void handleMessage(ArgumentDecoder* arguments, C* object, void (C::*function)(P1, P2, P3, P4, P5))
     138{
     139    typename RemoveReference<typename T::FirstArgumentType>::Type firstArgument;
     140    if (!arguments->decode(firstArgument))
     141        return;
     142    typename RemoveReference<typename T::SecondArgumentType>::Type secondArgument;
     143    if (!arguments->decode(secondArgument))
     144        return;
     145    typename RemoveReference<typename T::ThirdArgumentType>::Type thirdArgument;
     146    if (!arguments->decode(thirdArgument))
     147        return;
     148    typename RemoveReference<typename T::FourthArgumentType>::Type fourthArgument;
     149    if (!arguments->decode(fourthArgument))
     150        return;
     151    typename RemoveReference<typename T::FifthArgumentType>::Type fifthArgument;
     152    if (!arguments->decode(fifthArgument))
     153        return;
     154    (object->*function)(firstArgument, secondArgument, thirdArgument, fourthArgument, fifthArgument);
     155}
     156
     157template<typename T, typename C, typename P1, typename P2, typename P3, typename P4>
     158void handleMessage(ArgumentDecoder* arguments, C* object, void (C::*function)(P1, P2, P3, P4, CoreIPC::ArgumentDecoder*))
     159{
     160    typename RemoveReference<typename T::FirstArgumentType>::Type firstArgument;
     161    if (!arguments->decode(firstArgument))
     162        return;
     163    typename RemoveReference<typename T::SecondArgumentType>::Type secondArgument;
     164    if (!arguments->decode(secondArgument))
     165        return;
     166    typename RemoveReference<typename T::ThirdArgumentType>::Type thirdArgument;
     167    if (!arguments->decode(thirdArgument))
     168        return;
     169    typename RemoveReference<typename T::FourthArgumentType>::Type fourthArgument;
     170    if (!arguments->decode(fourthArgument))
     171        return;
     172    (object->*function)(firstArgument, secondArgument, thirdArgument, fourthArgument, arguments);
     173}
     174
    51175template<typename T, typename C, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
    52176void handleMessage(ArgumentDecoder* arguments, C* object, void (C::*function)(P1, P2, P3, P4, P5, P6))
    … …  
    110234}
    111235
     236template<typename T, typename C, typename P1, typename P2>
     237void handleMessage(ArgumentDecoder* arguments, ArgumentEncoder* reply, C* object, void (C::*function)(P1, P2))
     238{
     239    typename RemoveReference<typename T::FirstArgumentType>::Type firstArgument;
     240    if (!arguments->decode(firstArgument))
     241        return;
     242
     243    typename RemoveReference<typename T::SecondArgumentType>::Type secondArgument;
     244    if (!arguments->decode(secondArgument))
     245        return;
     246
     247    (object->*function)(firstArgument, secondArgument);
     248}
     249
     250template<typename T, typename C, typename P1, typename P2>
     251void handleMessage(ArgumentDecoder* arguments, ArgumentEncoder* reply, C* object, void (C::*function)(P1, const P2&))
     252{
     253    typename RemoveReference<typename T::FirstArgumentType>::Type firstArgument;
     254    if (!arguments->decode(firstArgument))
     255        return;
     256
     257    typename RemoveReference<typename T::SecondArgumentType>::Type secondArgument;
     258    if (!arguments->decode(secondArgument))
     259        return;
     260
     261    (object->*function)(firstArgument, secondArgument);
     262}
     263
     264template<typename T, typename C, typename R1>
     265void handleMessage(ArgumentDecoder* arguments, ArgumentEncoder* reply, C* object, void (C::*function)(R1&))
     266{
     267    typename RemoveReference<typename T::Reply::FirstArgumentType>::Type firstReplyArgument;
     268    (object->*function)(firstReplyArgument);
     269    reply->encode(firstReplyArgument);
     270}
     271
     272template<typename T, typename C, typename R1, typename R2>
     273void handleMessage(ArgumentDecoder* arguments, ArgumentEncoder* reply, C* object, void (C::*function)(R1&, R2&))
     274{
     275    typename RemoveReference<typename T::Reply::FirstArgumentType>::Type firstReplyArgument;
     276    typename RemoveReference<typename T::Reply::SecondArgumentType>::Type secondReplyArgument;
     277    (object->*function)(firstReplyArgument, secondReplyArgument);
     278    reply->encode(firstReplyArgument);
     279    reply->encode(secondReplyArgument);
     280}
     281
    112282template<typename T, typename C, typename P1, typename R1>
    113283void handleMessage(ArgumentDecoder* arguments, ArgumentEncoder* reply, C* object, void (C::*function)(P1, R1&))
    … …  
    122292}
    123293
     294template<typename T, typename C, typename P1, typename P2, typename R1>
     295void handleMessage(ArgumentDecoder* arguments, ArgumentEncoder* reply, C* object, void (C::*function)(P1, P2, R1&))
     296{
     297    typename RemoveReference<typename T::FirstArgumentType>::Type firstArgument;
     298    if (!arguments->decode(firstArgument))
     299        return;
     300
     301    typename RemoveReference<typename T::SecondArgumentType>::Type secondArgument;
     302    if (!arguments->decode(secondArgument))
     303        return;
     304   
     305    typename RemoveReference<typename T::Reply::FirstArgumentType>::Type firstReplyArgument;
     306    (object->*function)(firstArgument, secondArgument, firstReplyArgument);
     307    reply->encode(firstReplyArgument);
     308}
     309
    124310template<typename T, typename C, typename P1, typename P2, typename P3, typename R1>
    125311void handleMessage(ArgumentDecoder* arguments, ArgumentEncoder* reply, C* object, void (C::*function)(P1, P2, P3, R1&))
    … …  
    166352}
    167353
    168 template<typename T, typename C, typename P1, typename P2, typename R1>
    169 void handleMessage(ArgumentDecoder* arguments, ArgumentEncoder* reply, C* object, void (C::*function)(P1, P2, R1&))
    170 {
    171     typename RemoveReference<typename T::FirstArgumentType>::Type firstArgument;
    172     if (!arguments->decode(firstArgument))
    173         return;
    174 
    175     typename RemoveReference<typename T::SecondArgumentType>::Type secondArgument;
    176     if (!arguments->decode(secondArgument))
    177         return;
    178    
    179     typename RemoveReference<typename T::Reply::FirstArgumentType>::Type firstReplyArgument;
    180     (object->*function)(firstArgument, secondArgument, firstReplyArgument);
    181     reply->encode(firstReplyArgument);
    182 }
    183 
    184354} // namespace CoreIPC
    185355

  • trunk/WebKit2/Scripts/webkit2/messages.py

    r69029 r69210  
    145145    builtin_types = frozenset([
    146146        'bool',
     147        'double',
    147148        'float',
    148         'double',
    149         'uint8_t',
     149        'int16_t',
     150        'int32_t',
     151        'int64_t',
     152        'int8_t',
    150153        'uint16_t',
    151154        'uint32_t',
    152155        'uint64_t',
     156        'uint8_t',
    153157    ])
    154158
    … …  
    323327    special_cases = {
    324328        'WTF::String': '"ArgumentCoders.h"',
     329        'WebKit::InjectedBundleUserMessageEncoder': '"InjectedBundleUserMessageCoders.h"',
    325330    }
    326331
    … …  
    381386        type_headers = headers_for_type(type)
    382387        headers.update(type_headers)
     388
     389    for message in receiver.messages:
     390        if message.reply_parameters is not None:
     391            for reply_parameter in message.reply_parameters:
     392                type = reply_parameter.type
     393                argument_encoder_headers = argument_coder_headers_for_type(type)
     394                if argument_encoder_headers:
     395                    headers.update(argument_encoder_headers)
     396                    continue
     397
     398                type_headers = headers_for_type(type)
     399                headers.update(type_headers)
    383400
    384401    result = []

  • trunk/WebKit2/Scripts/webkit2/messages_unittest.py

    r69029 r69210  
    420420#include "ArgumentCoders.h"
    421421#include "ArgumentDecoder.h"
     422#include "Connection.h"
    422423#include "HandleMessage.h"
    423424#include "MachPort.h"
    424425#include "Plugin.h"
     426#include "WebCoreArgumentCoders.h"
    425427#include "WebEvent.h"
    426428#include "WebPageMessages.h"

  • trunk/WebKit2/UIProcess/API/mac/PageClientImpl.h

    r68318 r69210  
    5353    virtual void setCursor(const WebCore::Cursor&);
    5454
    55     void registerEditCommand(PassRefPtr<WebEditCommandProxy>, UndoOrRedo);
     55    void registerEditCommand(PassRefPtr<WebEditCommandProxy>, WebPageProxy::UndoOrRedo);
    5656    void clearAllEditCommands();
    5757    void setEditCommandState(const String& commandName, bool isEnabled, int state);

  • trunk/WebKit2/UIProcess/API/mac/PageClientImpl.mm

    r68364 r69210  
    184184}
    185185
    186 void PageClientImpl::registerEditCommand(PassRefPtr<WebEditCommandProxy> prpCommand, UndoOrRedo undoOrRedo)
     186void PageClientImpl::registerEditCommand(PassRefPtr<WebEditCommandProxy> prpCommand, WebPageProxy::UndoOrRedo undoOrRedo)
    187187{
    188188    RefPtr<WebEditCommandProxy> command = prpCommand;
    … …  
    192192
    193193    NSUndoManager *undoManager = [m_wkView undoManager];
    194     [undoManager registerUndoWithTarget:m_undoTarget.get() selector:((undoOrRedo == Undo) ? @selector(undoEditing:) : @selector(redoEditing:)) object:commandObjC.get()];
     194    [undoManager registerUndoWithTarget:m_undoTarget.get() selector:((undoOrRedo == WebPageProxy::Undo) ? @selector(undoEditing:) : @selector(redoEditing:)) object:commandObjC.get()];
    195195    if (actionName)
    196196        [undoManager setActionName:actionName];

  • trunk/WebKit2/UIProcess/API/qt/qwkpage.cpp

    r69108 r69210  
    8484}
    8585
    86 void QWKPagePrivate::registerEditCommand(PassRefPtr<WebEditCommandProxy>, UndoOrRedo)
     86void QWKPagePrivate::registerEditCommand(PassRefPtr<WebEditCommandProxy>, WebPageProxy::UndoOrRedo)
    8787{
    8888}

  • trunk/WebKit2/UIProcess/API/qt/qwkpage_p.h

    r68512 r69210  
    5454    virtual void takeFocus(bool direction) { }
    5555    virtual void toolTipChanged(const WTF::String&, const WTF::String&);
    56     virtual void registerEditCommand(PassRefPtr<WebKit::WebEditCommandProxy>, UndoOrRedo);
     56    virtual void registerEditCommand(PassRefPtr<WebKit::WebEditCommandProxy>, WebPageProxy::UndoOrRedo);
    5757    virtual void clearAllEditCommands();
    5858

  • trunk/WebKit2/UIProcess/PageClient.h

    r68318 r69210  
    2727#define PageClient_h
    2828
     29#include "WebPageProxy.h"
    2930#include <wtf/Forward.h>
    3031
    … …  
    4950    virtual void setCursor(const WebCore::Cursor&) = 0;
    5051
    51     enum UndoOrRedo { Undo, Redo };
    52     virtual void registerEditCommand(PassRefPtr<WebEditCommandProxy>, UndoOrRedo) = 0;
     52    virtual void registerEditCommand(PassRefPtr<WebEditCommandProxy>, WebPageProxy::UndoOrRedo) = 0;
    5353    virtual void clearAllEditCommands() = 0;
    5454    virtual void setEditCommandState(const String& commandName, bool isEnabled, int state) = 0;

  • trunk/WebKit2/UIProcess/WebEditCommandProxy.cpp

    r68079 r69210  
    5454
    5555    m_page->process()->send(Messages::WebPage::UnapplyEditCommand(m_commandID), m_page->pageID());
    56     m_page->registerEditCommandForRedo(this);
     56    m_page->registerEditCommand(this, WebPageProxy::Undo);
    5757}
    5858
    … …  
    6363
    6464    m_page->process()->send(Messages::WebPage::ReapplyEditCommand(m_commandID), m_page->pageID());
    65     m_page->registerEditCommandForUndo(this);
     65    m_page->registerEditCommand(this, WebPageProxy::Redo);
    6666}
    6767

  • trunk/WebKit2/UIProcess/WebFormClient.cpp

    r66789 r69210  
    4646}
    4747
    48 bool WebFormClient::willSubmitForm(WebPageProxy* page, WebFrameProxy* frame, WebFrameProxy* sourceFrame, Vector<std::pair<String, String> >& textFieldValues, APIObject* userData, WebFormSubmissionListenerProxy* listener)
     48bool WebFormClient::willSubmitForm(WebPageProxy* page, WebFrameProxy* frame, WebFrameProxy* sourceFrame, const Vector<std::pair<String, String> >& textFieldValues, APIObject* userData, WebFormSubmissionListenerProxy* listener)
    4949{
    5050    if (!m_pageFormClient.willSubmitForm)

  • trunk/WebKit2/UIProcess/WebFormClient.h

    r66789 r69210  
    4444    void initialize(const WKPageFormClient*);
    4545
    46     bool willSubmitForm(WebPageProxy*, WebFrameProxy*, WebFrameProxy*, Vector<std::pair<String, String> >& textFieldValues, APIObject* userData, WebFormSubmissionListenerProxy*);
     46    bool willSubmitForm(WebPageProxy*, WebFrameProxy*, WebFrameProxy*, const Vector<std::pair<String, String> >& textFieldValues, APIObject* userData, WebFormSubmissionListenerProxy*);
    4747
    4848private:

  • trunk/WebKit2/UIProcess/WebPageProxy.cpp

    r69116 r69210  
    3030#include "NativeWebKeyboardEvent.h"
    3131#include "PageClient.h"
     32#include "StringPairVector.h"
    3233#include "WebBackForwardList.h"
    3334#include "WebBackForwardListItem.h"
    … …  
    4445#include "WebPageMessages.h"
    4546#include "WebPageNamespace.h"
    46 #include "WebPageProxyMessageKinds.h"
    4747#include "WebPreferences.h"
    4848#include "WebProcessManager.h"
    … …  
    541541    }
    542542
    543     switch (messageID.get<WebPageProxyMessage::Kind>()) {
    544         case WebPageProxyMessage::DidCreateMainFrame: {
    545             uint64_t frameID;
    546             if (!arguments->decode(frameID))
    547                 return;
    548             didCreateMainFrame(frameID);
    549             break;
    550         }
    551         case WebPageProxyMessage::DidCreateSubFrame: {
    552             uint64_t frameID;
    553             if (!arguments->decode(frameID))
    554                 return;
    555             didCreateSubFrame(frameID);
    556             break;
    557         }
    558         case WebPageProxyMessage::DidStartProvisionalLoadForFrame: {
    559             uint64_t frameID;
    560             String url;
    561 
    562             RefPtr<APIObject> userData;
    563             WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
    564 
    565             if (!arguments->decode(CoreIPC::Out(frameID, url, messageDecoder)))
    566                 return;
    567 
    568             didStartProvisionalLoadForFrame(process()->webFrame(frameID), url, userData.get());
    569             break;
    570         }
    571         case WebPageProxyMessage::DidReceiveServerRedirectForProvisionalLoadForFrame: {
    572             uint64_t frameID;
    573             String url;
    574 
    575             RefPtr<APIObject> userData;
    576             WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
    577 
    578             if (!arguments->decode(CoreIPC::Out(frameID, url, messageDecoder)))
    579                 return;
    580 
    581             didReceiveServerRedirectForProvisionalLoadForFrame(process()->webFrame(frameID), url, userData.get());
    582             break;
    583         }
    584         case WebPageProxyMessage::DidFailProvisionalLoadForFrame: {
    585             uint64_t frameID;
    586            
    587             RefPtr<APIObject> userData;
    588             WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
    589 
    590             if (!arguments->decode(CoreIPC::Out(frameID, messageDecoder)))
    591                 return;
    592 
    593             didFailProvisionalLoadForFrame(process()->webFrame(frameID), userData.get());
    594             break;
    595         }
    596         case WebPageProxyMessage::DidCommitLoadForFrame: {
    597             uint64_t frameID;
    598             String mimeType;
    599             PlatformCertificateInfo certificateInfo;
    600 
    601             RefPtr<APIObject> userData;
    602             WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
    603 
    604             if (!arguments->decode(CoreIPC::Out(frameID, mimeType, certificateInfo, messageDecoder)))
    605                 return;
    606    
    607             didCommitLoadForFrame(process()->webFrame(frameID), mimeType, certificateInfo, userData.get());
    608             break;
    609         }
    610         case WebPageProxyMessage::DidFinishDocumentLoadForFrame: {
    611             uint64_t frameID;
    612 
    613             RefPtr<APIObject> userData;
    614             WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
    615 
    616             if (!arguments->decode(CoreIPC::Out(frameID, messageDecoder)))
    617                 return;
    618 
    619             didFinishDocumentLoadForFrame(process()->webFrame(frameID), userData.get());
    620             break;
    621         }
    622         case WebPageProxyMessage::DidFinishLoadForFrame: {
    623             uint64_t frameID;
    624 
    625             RefPtr<APIObject> userData;
    626             WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
    627 
    628             if (!arguments->decode(CoreIPC::Out(frameID, messageDecoder)))
    629                 return;
    630 
    631             didFinishLoadForFrame(process()->webFrame(frameID), userData.get());
    632             break;
    633         }
    634         case WebPageProxyMessage::DidFailLoadForFrame: {
    635             uint64_t frameID;
    636 
    637             RefPtr<APIObject> userData;
    638             WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
    639 
    640             if (!arguments->decode(CoreIPC::Out(frameID, messageDecoder)))
    641                 return;
    642 
    643             didFailLoadForFrame(process()->webFrame(frameID), userData.get());
    644             break;
    645         }
    646         case WebPageProxyMessage::DidReceiveTitleForFrame: {
    647             uint64_t frameID;
    648             String title;
    649 
    650             RefPtr<APIObject> userData;
    651             WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
    652 
    653             if (!arguments->decode(CoreIPC::Out(frameID, title, messageDecoder)))
    654                 return;
    655 
    656             didReceiveTitleForFrame(process()->webFrame(frameID), title, userData.get());
    657             break;
    658         }
    659         case WebPageProxyMessage::DidFirstLayoutForFrame: {
    660             uint64_t frameID;
    661 
    662             RefPtr<APIObject> userData;
    663             WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
    664 
    665             if (!arguments->decode(CoreIPC::Out(frameID, messageDecoder)))
    666                 return;
    667 
    668             didFirstLayoutForFrame(process()->webFrame(frameID), userData.get());
    669             break;
    670         }
    671         case WebPageProxyMessage::DidFirstVisuallyNonEmptyLayoutForFrame: {
    672             uint64_t frameID;
    673 
    674             RefPtr<APIObject> userData;
    675             WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
    676 
    677             if (!arguments->decode(CoreIPC::Out(frameID, messageDecoder)))
    678                 return;
    679 
    680             didFirstVisuallyNonEmptyLayoutForFrame(process()->webFrame(frameID), userData.get());
    681             break;
    682         }
    683         case WebPageProxyMessage::DidRemoveFrameFromHierarchy: {
    684             uint64_t frameID;
    685 
    686             RefPtr<APIObject> userData;
    687             WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
    688 
    689             if (!arguments->decode(CoreIPC::Out(frameID, messageDecoder)))
    690                 return;
    691 
    692             didRemoveFrameFromHierarchy(process()->webFrame(frameID), userData.get());
    693             break;
    694         }
    695         case WebPageProxyMessage::DidStartProgress:
    696             didStartProgress();
    697             break;
    698         case WebPageProxyMessage::DidChangeProgress: {
    699             double value;
    700             if (!arguments->decode(value))
    701                 return;
    702             didChangeProgress(value);
    703             break;
    704         }
    705         case WebPageProxyMessage::DidFinishProgress:
    706             didFinishProgress();
    707             break;
    708         case WebPageProxyMessage::DidReceiveEvent: {
    709             uint32_t type;
    710             bool handled;
    711             if (!arguments->decode(CoreIPC::Out(type, handled)))
    712                 return;
    713             didReceiveEvent((WebEvent::Type)type, handled);
    714             break;
    715         }
    716         case WebPageProxyMessage::TakeFocus: {
    717             // FIXME: Use enum here.
    718             bool direction;
    719             if (!arguments->decode(direction))
    720                 return;
    721             takeFocus(direction);
    722             break;
    723         }
    724         case WebPageProxyMessage::DecidePolicyForNavigationAction: {
    725             uint64_t frameID;
    726             uint32_t navigationType;
    727             uint32_t modifiers;
    728             int32_t mouseButton;
    729             String url;
    730             uint64_t listenerID;
    731             if (!arguments->decode(CoreIPC::Out(frameID, navigationType, modifiers, mouseButton, url, listenerID)))
    732                 return;
    733             decidePolicyForNavigationAction(process()->webFrame(frameID), static_cast<NavigationType>(navigationType), static_cast<WebEvent::Modifiers>(modifiers), static_cast<WebMouseEvent::Button>(mouseButton), url, listenerID);
    734             break;
    735         }
    736         case WebPageProxyMessage::DecidePolicyForNewWindowAction: {
    737             uint64_t frameID;
    738             uint32_t navigationType;
    739             uint32_t modifiers;
    740             int32_t mouseButton;
    741             String url;
    742             uint64_t listenerID;
    743             if (!arguments->decode(CoreIPC::Out(frameID, navigationType, modifiers, mouseButton, url, listenerID)))
    744                 return;
    745             decidePolicyForNewWindowAction(process()->webFrame(frameID), static_cast<NavigationType>(navigationType), static_cast<WebEvent::Modifiers>(modifiers), static_cast<WebMouseEvent::Button>(mouseButton), url, listenerID);
    746             break;
    747         }
    748         case WebPageProxyMessage::DecidePolicyForMIMEType: {
    749             uint64_t frameID;
    750             String MIMEType;
    751             String url;
    752             uint64_t listenerID;
    753             if (!arguments->decode(CoreIPC::Out(frameID, MIMEType, url, listenerID)))
    754                 return;
    755             decidePolicyForMIMEType(process()->webFrame(frameID), MIMEType, url, listenerID);
    756             break;
    757         }
    758         case WebPageProxyMessage::WillSubmitForm: {
    759             uint64_t frameID;
    760             uint64_t sourceFrameID;
    761             Vector<std::pair<String, String> > textFieldValues;
    762             uint64_t listenerID;
    763 
    764             RefPtr<APIObject> userData;
    765             WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
    766 
    767             if (!arguments->decode(CoreIPC::Out(frameID, sourceFrameID, textFieldValues, listenerID, messageDecoder)))
    768                 return;
    769 
    770             willSubmitForm(process()->webFrame(frameID), process()->webFrame(sourceFrameID), textFieldValues, userData.get(), listenerID);
    771             break;
    772         }
    773         case WebPageProxyMessage::DidRunJavaScriptInMainFrame: {
    774             String resultString;
    775             uint64_t callbackID;
    776             if (!arguments->decode(CoreIPC::Out(resultString, callbackID)))
    777                 return;
    778             didRunJavaScriptInMainFrame(resultString, callbackID);
    779             break;
    780         }
    781         case WebPageProxyMessage::DidGetRenderTreeExternalRepresentation: {
    782             String resultString;
    783             uint64_t callbackID;
    784             if (!arguments->decode(CoreIPC::Out(resultString, callbackID)))
    785                 return;
    786             didGetRenderTreeExternalRepresentation(resultString, callbackID);
    787             break;
    788         }
    789         case WebPageProxyMessage::DidGetSourceForFrame: {
    790             String resultString;
    791             uint64_t callbackID;
    792             if (!arguments->decode(CoreIPC::Out(resultString, callbackID)))
    793                 return;
    794             didGetSourceForFrame(resultString, callbackID);
    795             break;
    796         }
    797         case WebPageProxyMessage::SetToolTip: {
    798             String toolTip;
    799             if (!arguments->decode(toolTip))
    800                 return;
    801             setToolTip(toolTip);
    802             break;
    803         }
    804         case WebPageProxyMessage::SetCursor: {
    805 #if USE(LAZY_NATIVE_CURSOR)
    806             Cursor cursor;
    807             if (!arguments->decode(cursor))
    808                 return;
    809             setCursor(cursor);
    810 #endif
    811             break;
    812         }
    813         case WebPageProxyMessage::ShowPage: {
    814             showPage();
    815             break;
    816         }
    817         case WebPageProxyMessage::ClosePage: {
    818             closePage();
    819             break;
    820         }
    821         case WebPageProxyMessage::BackForwardAddItem: {
    822             uint64_t itemID;
    823             if (!arguments->decode(CoreIPC::Out(itemID)))
    824                 return;
    825             addItemToBackForwardList(process()->webBackForwardItem(itemID));
    826             break;
    827         }
    828         case WebPageProxyMessage::BackForwardGoToItem: {
    829             uint64_t itemID;
    830             if (!arguments->decode(CoreIPC::Out(itemID)))
    831                 return;
    832             goToItemInBackForwardList(process()->webBackForwardItem(itemID));
    833             break;
    834         }
    835         case WebPageProxyMessage::ContentsSizeChanged: {
    836             IntSize size;
    837             uint64_t frameID;
    838             if (!arguments->decode(CoreIPC::Out(frameID, size)))
    839                 return;
    840             contentsSizeChanged(process()->webFrame(frameID), size);
    841             break;
    842         }
    843         case WebPageProxyMessage::SetStatusText: {
    844             String text;
    845             if (!arguments->decode(CoreIPC::Out(text)))
    846                 return;
    847             setStatusText(text);
    848             break;
    849         }
    850         case WebPageProxyMessage::RegisterEditCommandForUndo: {
    851             uint64_t commandID;
    852             uint32_t editAction;
    853             if (!arguments->decode(CoreIPC::Out(commandID, editAction)))
    854                 return;
    855                
    856             registerEditCommandForUndo(commandID, static_cast<EditAction>(editAction));
    857             break;
    858         }
    859         case WebPageProxyMessage::ClearAllEditCommands:
    860             clearAllEditCommands();
    861             break;
    862         case WebPageProxyMessage::DidValidateMenuItem: {
    863             int state;
    864             bool isEnabled;
    865             String commandName;
    866             if (!arguments->decode(CoreIPC::Out(commandName, isEnabled, state)))
    867                 return;
    868             m_pageClient->setEditCommandState(commandName, isEnabled, state);
    869             break;
    870         }
    871         case WebPageProxyMessage::MouseDidMoveOverElement: {
    872             uint32_t modifiers;
    873             RefPtr<APIObject> userData;
    874             WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
    875 
    876             if (!arguments->decode(CoreIPC::Out(modifiers, messageDecoder)))
    877                 return;
    878 
    879             mouseDidMoveOverElement(static_cast<WebEvent::Modifiers>(modifiers), userData.get());
    880             break;
    881         }
    882         default:
    883             ASSERT_NOT_REACHED();
    884             break;
    885     }
     543    didReceiveWebPageProxyMessage(connection, messageID, arguments);
     544
    886545}
    887546
    … …  
    893552    }
    894553
    895     switch (messageID.get<WebPageProxyMessage::Kind>()) {
    896         case WebPageProxyMessage::CreateNewPage: {
    897             RefPtr<WebPageProxy> newPage = createNewPage();
    898             WebPageCreationParameters parameters;
    899             if (newPage) {
    900                 // FIXME: Pass the real size.
    901                 parameters = newPage->creationParameters(IntSize(100, 100));
    902                 reply->encode(CoreIPC::In(newPage->pageID(), parameters));
    903             } else {
    904                 reply->encode(CoreIPC::In(static_cast<uint64_t>(0), parameters));
    905             }
    906             break;
    907         }
    908         case WebPageProxyMessage::RunJavaScriptAlert: {
    909             uint64_t frameID;
    910             String message;
    911             if (!arguments->decode(CoreIPC::Out(frameID, message)))
    912                 return;
    913             runJavaScriptAlert(process()->webFrame(frameID), message);
    914             break;
    915         }
    916         case WebPageProxyMessage::RunJavaScriptConfirm: {
    917             // FIXME: We should probably encode something in the case that the arguments do not decode correctly.
    918             uint64_t frameID;
    919             String message;
    920             if (!arguments->decode(CoreIPC::Out(frameID, message)))
    921                 return;
    922 
    923             bool result = runJavaScriptConfirm(process()->webFrame(frameID), message);
    924             reply->encode(CoreIPC::In(result));
    925             break;
    926         }
    927         case WebPageProxyMessage::RunJavaScriptPrompt: {
    928             // FIXME: We should probably encode something in the case that the arguments do not decode correctly.
    929             uint64_t frameID;
    930             String message;
    931             String defaultValue;
    932             if (!arguments->decode(CoreIPC::Out(frameID, message, defaultValue)))
    933                 return;
    934 
    935             String result = runJavaScriptPrompt(process()->webFrame(frameID), message, defaultValue);
    936             reply->encode(CoreIPC::In(result));
    937             break;
    938         }
    939 
    940         case WebPageProxyMessage::BackForwardBackItem: {
    941             WebBackForwardListItem* backItem = m_backForwardList->backItem();
    942             uint64_t backItemID = backItem ? backItem->itemID() : 0;
    943             reply->encode(CoreIPC::In(backItemID));
    944             break;
    945         }
    946         case WebPageProxyMessage::BackForwardCurrentItem: {
    947             WebBackForwardListItem* currentItem = m_backForwardList->currentItem();
    948             uint64_t currentItemID = currentItem ? currentItem->itemID() : 0;
    949             reply->encode(CoreIPC::In(currentItemID));
    950             break;
    951         }
    952         case WebPageProxyMessage::BackForwardForwardItem: {
    953             WebBackForwardListItem* forwardItem = m_backForwardList->forwardItem();
    954             uint64_t forwardItemID = forwardItem ? forwardItem->itemID() : 0;
    955             reply->encode(CoreIPC::In(forwardItemID));
    956             break;
    957         }
    958         case WebPageProxyMessage::BackForwardItemAtIndex: {
    959             int itemIndex;
    960             if (!arguments->decode(CoreIPC::Out(itemIndex)))
    961                 return;
    962 
    963             WebBackForwardListItem* item = m_backForwardList->itemAtIndex(itemIndex);
    964             uint64_t itemID = item ? item->itemID() : 0;
    965             reply->encode(CoreIPC::In(itemID));
    966             break;
    967         }
    968         case WebPageProxyMessage::BackForwardBackListCount: {
    969             int backListCount = m_backForwardList->backListCount();
    970             reply->encode(CoreIPC::In(backListCount));
    971             break;
    972         }
    973         case WebPageProxyMessage::BackForwardForwardListCount: {
    974             int forwardListCount = m_backForwardList->forwardListCount();
    975             reply->encode(CoreIPC::In(forwardListCount));
    976             break;
    977         }
    978 #if USE(ACCELERATED_COMPOSITING)
    979         case WebPageProxyMessage::DidChangeAcceleratedCompositing: {
    980             bool compositing;
    981             if (!arguments->decode(CoreIPC::Out(compositing)))
    982                 return;
    983 
    984             didChangeAcceleratedCompositing(compositing);
    985             reply->encode(drawingArea()->info());
    986             break;
    987         }
    988 #endif // USE(ACCELERATED_COMPOSITING)
    989 
    990         default:
    991             ASSERT_NOT_REACHED();
    992             break;
    993     }
     554    // FIXME: Do something with reply.
     555    didReceiveSyncWebPageProxyMessage(connection, messageID, arguments, reply);
    994556}
    995557
    … …  
    1029591}
    1030592
    1031 void WebPageProxy::didStartProvisionalLoadForFrame(WebFrameProxy* frame, const String& url, APIObject* userData)
    1032 {
     593void WebPageProxy::didStartProvisionalLoadForFrame(uint64_t frameID, const String& url, CoreIPC::ArgumentDecoder* arguments)
     594{
     595    RefPtr<APIObject> userData;
     596    WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
     597    if (!arguments->decode(messageDecoder))
     598        return;
     599
     600    WebFrameProxy* frame = process()->webFrame(frameID);
     601
    1033602    frame->didStartProvisionalLoad(url);
    1034     m_loaderClient.didStartProvisionalLoadForFrame(this, frame, userData);
    1035 }
    1036 
    1037 void WebPageProxy::didReceiveServerRedirectForProvisionalLoadForFrame(WebFrameProxy* frame, const String& url, APIObject* userData)
    1038 {
     603    m_loaderClient.didStartProvisionalLoadForFrame(this, frame, userData.get());
     604}
     605
     606void WebPageProxy::didReceiveServerRedirectForProvisionalLoadForFrame(uint64_t frameID, const String& url, CoreIPC::ArgumentDecoder* arguments)
     607{
     608    RefPtr<APIObject> userData;
     609    WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
     610    if (!arguments->decode(messageDecoder))
     611        return;
     612
     613    WebFrameProxy* frame = process()->webFrame(frameID);
     614
    1039615    frame->didReceiveServerRedirectForProvisionalLoad(url);
    1040     m_loaderClient.didReceiveServerRedirectForProvisionalLoadForFrame(this, frame, userData);
    1041 }
    1042 
    1043 void WebPageProxy::didFailProvisionalLoadForFrame(WebFrameProxy* frame, APIObject* userData)
    1044 {
    1045     m_loaderClient.didFailProvisionalLoadWithErrorForFrame(this, frame, userData);
    1046 }
    1047 
    1048 void WebPageProxy::didCommitLoadForFrame(WebFrameProxy* frame, const String& mimeType, const PlatformCertificateInfo& certificateInfo, APIObject* userData)
    1049 {
     616    m_loaderClient.didReceiveServerRedirectForProvisionalLoadForFrame(this, frame, userData.get());
     617}
     618
     619void WebPageProxy::didFailProvisionalLoadForFrame(uint64_t frameID, CoreIPC::ArgumentDecoder* arguments)
     620{
     621    RefPtr<APIObject> userData;
     622    WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
     623    if (!arguments->decode(messageDecoder))
     624        return;
     625
     626    WebFrameProxy* frame = process()->webFrame(frameID);
     627
     628    m_loaderClient.didFailProvisionalLoadWithErrorForFrame(this, frame, userData.get());
     629}
     630
     631void WebPageProxy::didCommitLoadForFrame(uint64_t frameID, const String& mimeType, const PlatformCertificateInfo& certificateInfo, CoreIPC::ArgumentDecoder* arguments)
     632{
     633    RefPtr<APIObject> userData;
     634    WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
     635    if (!arguments->decode(messageDecoder))
     636        return;
     637
     638    WebFrameProxy* frame = process()->webFrame(frameID);
     639
    1050640    frame->setMIMEType(mimeType);
    1051641    frame->setCertificateInfo(WebCertificateInfo::create(certificateInfo));
    1052642    frame->didCommitLoad();
    1053     m_loaderClient.didCommitLoadForFrame(this, frame, userData);
    1054 }
    1055 
    1056 void WebPageProxy::didFinishDocumentLoadForFrame(WebFrameProxy* frame, APIObject* userData)
    1057 {
    1058     m_loaderClient.didFinishDocumentLoadForFrame(this, frame, userData);
    1059 }
    1060 
    1061 void WebPageProxy::didFinishLoadForFrame(WebFrameProxy* frame, APIObject* userData)
    1062 {
     643    m_loaderClient.didCommitLoadForFrame(this, frame, userData.get());
     644}
     645
     646void WebPageProxy::didFinishDocumentLoadForFrame(uint64_t frameID, CoreIPC::ArgumentDecoder* arguments)
     647{
     648    RefPtr<APIObject> userData;
     649    WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
     650    if (!arguments->decode(messageDecoder))
     651        return;
     652
     653    WebFrameProxy* frame = process()->webFrame(frameID);
     654
     655    m_loaderClient.didFinishDocumentLoadForFrame(this, frame, userData.get());
     656}
     657
     658void WebPageProxy::didFinishLoadForFrame(uint64_t frameID, CoreIPC::ArgumentDecoder* arguments)
     659{
     660    RefPtr<APIObject> userData;
     661    WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
     662    if (!arguments->decode(messageDecoder))
     663        return;
     664
     665    WebFrameProxy* frame = process()->webFrame(frameID);
     666
    1063667    frame->didFinishLoad();
    1064     m_loaderClient.didFinishLoadForFrame(this, frame, userData);
    1065 }
    1066 
    1067 void WebPageProxy::didFailLoadForFrame(WebFrameProxy* frame, APIObject* userData)
    1068 {
    1069     m_loaderClient.didFailLoadWithErrorForFrame(this, frame, userData);
    1070 }
    1071 
    1072 void WebPageProxy::didReceiveTitleForFrame(WebFrameProxy* frame, const String& title, APIObject* userData)
    1073 {
     668    m_loaderClient.didFinishLoadForFrame(this, frame, userData.get());
     669}
     670
     671void WebPageProxy::didFailLoadForFrame(uint64_t frameID, CoreIPC::ArgumentDecoder* arguments)
     672{
     673    RefPtr<APIObject> userData;
     674    WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
     675    if (!arguments->decode(messageDecoder))
     676        return;
     677
     678    WebFrameProxy* frame = process()->webFrame(frameID);
     679
     680    m_loaderClient.didFailLoadWithErrorForFrame(this, frame, userData.get());
     681}
     682
     683void WebPageProxy::didReceiveTitleForFrame(uint64_t frameID, const String& title, CoreIPC::ArgumentDecoder* arguments)
     684{
     685    RefPtr<APIObject> userData;
     686    WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
     687    if (!arguments->decode(messageDecoder))
     688        return;
     689
     690    WebFrameProxy* frame = process()->webFrame(frameID);
     691
    1074692    frame->didReceiveTitle(title);
    1075693
    … …  
    1078696        m_pageTitle = title;
    1079697
    1080     m_loaderClient.didReceiveTitleForFrame(this, title, frame, userData);
    1081 }
    1082 
    1083 void WebPageProxy::didFirstLayoutForFrame(WebFrameProxy* frame, APIObject* userData)
    1084 {
    1085     m_loaderClient.didFirstLayoutForFrame(this, frame, userData);
    1086 }
    1087 
    1088 void WebPageProxy::didFirstVisuallyNonEmptyLayoutForFrame(WebFrameProxy* frame, APIObject* userData)
    1089 {
    1090     m_loaderClient.didFirstVisuallyNonEmptyLayoutForFrame(this, frame, userData);
    1091 }
    1092 
    1093 void WebPageProxy::didRemoveFrameFromHierarchy(WebFrameProxy* frame, APIObject* userData)
    1094 {
    1095     m_loaderClient.didRemoveFrameFromHierarchy(this, frame, userData);
     698    m_loaderClient.didReceiveTitleForFrame(this, title, frame, userData.get());
     699}
     700
     701void WebPageProxy::didFirstLayoutForFrame(uint64_t frameID, CoreIPC::ArgumentDecoder* arguments)
     702{
     703    RefPtr<APIObject> userData;
     704    WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
     705    if (!arguments->decode(messageDecoder))
     706        return;
     707
     708    WebFrameProxy* frame = process()->webFrame(frameID);
     709
     710    m_loaderClient.didFirstLayoutForFrame(this, frame, userData.get());
     711}
     712
     713void WebPageProxy::didFirstVisuallyNonEmptyLayoutForFrame(uint64_t frameID, CoreIPC::ArgumentDecoder* arguments)
     714{
     715    RefPtr<APIObject> userData;
     716    WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
     717    if (!arguments->decode(messageDecoder))
     718        return;
     719
     720    WebFrameProxy* frame = process()->webFrame(frameID);
     721
     722    m_loaderClient.didFirstVisuallyNonEmptyLayoutForFrame(this, frame, userData.get());
     723}
     724
     725void WebPageProxy::didRemoveFrameFromHierarchy(uint64_t frameID, CoreIPC::ArgumentDecoder* arguments)
     726{
     727    RefPtr<APIObject> userData;
     728    WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
     729    if (!arguments->decode(messageDecoder))
     730        return;
     731
     732    WebFrameProxy* frame = process()->webFrame(frameID);
     733
     734    m_loaderClient.didRemoveFrameFromHierarchy(this, frame, userData.get());
    1096735}
    1097736
    1098737// PolicyClient
    1099738
    1100 void WebPageProxy::decidePolicyForNavigationAction(WebFrameProxy* frame, NavigationType navigationType, WebEvent::Modifiers modifiers, WebMouseEvent::Button mouseButton, const String& url, uint64_t listenerID)
    1101 {
     739void WebPageProxy::decidePolicyForNavigationAction(uint64_t frameID, uint32_t opaqueNavigationType, uint32_t opaqueModifiers, int32_t opaqueMouseButton, const String& url, uint64_t listenerID)
     740{
     741    WebFrameProxy* frame = process()->webFrame(frameID);
     742    NavigationType navigationType = static_cast<NavigationType>(opaqueNavigationType);
     743    WebEvent::Modifiers modifiers = static_cast<WebEvent::Modifiers>(opaqueModifiers);
     744    WebMouseEvent::Button mouseButton = static_cast<WebMouseEvent::Button>(opaqueMouseButton);
     745   
    1102746    RefPtr<WebFramePolicyListenerProxy> listener = frame->setUpPolicyListenerProxy(listenerID);
    1103747    if (!m_policyClient.decidePolicyForNavigationAction(this, navigationType, modifiers, mouseButton, url, frame, listener.get()))
    … …  
    1105749}
    1106750
    1107 void WebPageProxy::decidePolicyForNewWindowAction(WebFrameProxy* frame, NavigationType navigationType, WebEvent::Modifiers modifiers, WebMouseEvent::Button mouseButton, const String& url, uint64_t listenerID)
    1108 {
     751void WebPageProxy::decidePolicyForNewWindowAction(uint64_t frameID, uint32_t opaqueNavigationType, uint32_t opaqueModifiers, int32_t opaqueMouseButton, const String& url, uint64_t listenerID)
     752{
     753    WebFrameProxy* frame = process()->webFrame(frameID);
     754    NavigationType navigationType = static_cast<NavigationType>(opaqueNavigationType);
     755    WebEvent::Modifiers modifiers = static_cast<WebEvent::Modifiers>(opaqueModifiers);
     756    WebMouseEvent::Button mouseButton = static_cast<WebMouseEvent::Button>(opaqueMouseButton);
     757
    1109758    RefPtr<WebFramePolicyListenerProxy> listener = frame->setUpPolicyListenerProxy(listenerID);
    1110759    if (!m_policyClient.decidePolicyForNewWindowAction(this, navigationType, modifiers, mouseButton, url, frame, listener.get()))
    … …  
    1112761}
    1113762
    1114 void WebPageProxy::decidePolicyForMIMEType(WebFrameProxy* frame, const String& MIMEType, const String& url, uint64_t listenerID)
    1115 {
     763void WebPageProxy::decidePolicyForMIMEType(uint64_t frameID, const String& MIMEType, const String& url, uint64_t listenerID)
     764{
     765    WebFrameProxy* frame = process()->webFrame(frameID);
    1116766    RefPtr<WebFramePolicyListenerProxy> listener = frame->setUpPolicyListenerProxy(listenerID);
    1117767    if (!m_policyClient.decidePolicyForMIMEType(this, MIMEType, url, frame, listener.get()))
    … …  
    1121771// FormClient
    1122772
    1123 void WebPageProxy::willSubmitForm(WebFrameProxy* frame, WebFrameProxy* sourceFrame, Vector<std::pair<String, String> >& textFieldValues, APIObject* userData, uint64_t listenerID)
    1124 {
     773void WebPageProxy::willSubmitForm(uint64_t frameID, uint64_t sourceFrameID, const StringPairVector& textFieldValues, uint64_t listenerID, CoreIPC::ArgumentDecoder* arguments)
     774{
     775    RefPtr<APIObject> userData;
     776    WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
     777    if (!arguments->decode(messageDecoder))
     778        return;
     779
     780    WebFrameProxy* frame = process()->webFrame(frameID);
     781    WebFrameProxy* sourceFrame = process()->webFrame(sourceFrameID);
     782
    1125783    RefPtr<WebFormSubmissionListenerProxy> listener = frame->setUpFormSubmissionListenerProxy(listenerID);
    1126     if (!m_formClient.willSubmitForm(this, frame, sourceFrame, textFieldValues, userData, listener.get()))
     784    if (!m_formClient.willSubmitForm(this, frame, sourceFrame, textFieldValues.stringPairVector(), userData.get(), listener.get()))
    1127785        listener->continueSubmission();
    1128786}
    … …  
    1130788// UIClient
    1131789
    1132 PassRefPtr<WebPageProxy> WebPageProxy::createNewPage()
    1133 {
    1134     return m_uiClient.createNewPage(this);
     790void WebPageProxy::createNewPage(uint64_t& newPageID, WebPageCreationParameters& newPageParameters)
     791{
     792    RefPtr<WebPageProxy> newPage = m_uiClient.createNewPage(this);
     793    if (newPage) {
     794        // FIXME: Pass the real size.
     795        newPageID = newPage->pageID();
     796        newPageParameters = newPage->creationParameters(IntSize(100, 100));
     797    } else
     798        newPageID = 0;
    1135799}
    1136800   
    … …  
    1145809}
    1146810
    1147 void WebPageProxy::runJavaScriptAlert(WebFrameProxy* frame, const String& message)
    1148 {
    1149     m_uiClient.runJavaScriptAlert(this, message, frame);
    1150 }
    1151 
    1152 bool WebPageProxy::runJavaScriptConfirm(WebFrameProxy* frame, const String& message)
    1153 {
    1154     return m_uiClient.runJavaScriptConfirm(this, message, frame);
    1155 }
    1156 
    1157 String WebPageProxy::runJavaScriptPrompt(WebFrameProxy* frame, const String& message, const String& defaultValue)
    1158 {
    1159     return m_uiClient.runJavaScriptPrompt(this, message, defaultValue, frame);
     811void WebPageProxy::runJavaScriptAlert(uint64_t frameID, const String& message)
     812{
     813    m_uiClient.runJavaScriptAlert(this, message, process()->webFrame(frameID));
     814}
     815
     816void WebPageProxy::runJavaScriptConfirm(uint64_t frameID, const String& message, bool& result)
     817{
     818    result = m_uiClient.runJavaScriptConfirm(this, message, process()->webFrame(frameID));
     819}
     820
     821void WebPageProxy::runJavaScriptPrompt(uint64_t frameID, const String& message, const String& defaultValue, String& result)
     822{
     823    result = m_uiClient.runJavaScriptPrompt(this, message, defaultValue, process()->webFrame(frameID));
    1160824}
    1161825
    … …  
    1165829}
    1166830
    1167 void WebPageProxy::mouseDidMoveOverElement(WebEvent::Modifiers modifiers, APIObject* userData)
    1168 {
    1169     m_uiClient.mouseDidMoveOverElement(this, modifiers, userData);
    1170 }
    1171 
    1172 void WebPageProxy::contentsSizeChanged(WebFrameProxy* frame, const WebCore::IntSize& size)
    1173 {
    1174     m_uiClient.contentsSizeChanged(this, size, frame);
     831void WebPageProxy::mouseDidMoveOverElement(uint32_t opaqueModifiers, CoreIPC::ArgumentDecoder* arguments)
     832{
     833
     834    RefPtr<APIObject> userData;
     835    WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
     836    if (!arguments->decode(messageDecoder))
     837        return;
     838
     839    WebEvent::Modifiers modifiers = static_cast<WebEvent::Modifiers>(opaqueModifiers);
     840
     841    m_uiClient.mouseDidMoveOverElement(this, modifiers, userData.get());
     842}
     843
     844void WebPageProxy::contentsSizeChanged(uint64_t frameID, const WebCore::IntSize& size)
     845{
     846    m_uiClient.contentsSizeChanged(this, size, process()->webFrame(frameID));
    1175847}
    1176848
    1177849// BackForwardList
    1178850
    1179 void WebPageProxy::addItemToBackForwardList(WebBackForwardListItem* item)
    1180 {
    1181     m_backForwardList->addItem(item);
    1182 }
    1183 
    1184 void WebPageProxy::goToItemInBackForwardList(WebBackForwardListItem* item)
    1185 {
    1186     m_backForwardList->goToItem(item);
     851void WebPageProxy::backForwardAddItem(uint64_t itemID)
     852{
     853    m_backForwardList->addItem(process()->webBackForwardItem(itemID));
     854}
     855
     856void WebPageProxy::backForwardGoToItem(uint64_t itemID)
     857{
     858    m_backForwardList->goToItem(process()->webBackForwardItem(itemID));
     859}
     860
     861void WebPageProxy::backForwardBackItem(uint64_t& itemID)
     862{
     863    WebBackForwardListItem* backItem = m_backForwardList->backItem();
     864    itemID = backItem ? backItem->itemID() : 0;
     865}
     866
     867void WebPageProxy::backForwardCurrentItem(uint64_t& itemID)
     868{
     869    WebBackForwardListItem* currentItem = m_backForwardList->currentItem();
     870    itemID = currentItem ? currentItem->itemID() : 0;
     871}
     872
     873void WebPageProxy::backForwardForwardItem(uint64_t& itemID)
     874{
     875    WebBackForwardListItem* forwardItem = m_backForwardList->forwardItem();
     876    itemID = forwardItem ? forwardItem->itemID() : 0;
     877}
     878
     879void WebPageProxy::backForwardItemAtIndex(int32_t index, uint64_t& itemID)
     880{
     881    WebBackForwardListItem* item = m_backForwardList->itemAtIndex(index);;
     882    itemID = item ? item->itemID() : 0;
     883}
     884
     885void WebPageProxy::backForwardBackListCount(int32_t& count)
     886{
     887    count = m_backForwardList->backListCount();
     888}
     889
     890void WebPageProxy::backForwardForwardListCount(int32_t& count)
     891{
     892    count = m_backForwardList->forwardListCount();
    1187893}
    1188894
    1189895// Undo management
    1190896
    1191 void WebPageProxy::registerEditCommandForUndo(uint64_t commandID, EditAction editAction)
    1192 {
    1193     registerEditCommandForUndo(WebEditCommandProxy::create(commandID, editAction, this));
     897void WebPageProxy::registerEditCommandForUndo(uint64_t commandID, uint32_t editAction)
     898{
     899    registerEditCommand(WebEditCommandProxy::create(commandID, static_cast<EditAction>(editAction), this), Undo);
    1194900}
    1195901
    … …  
    1199905}
    1200906
    1201 void WebPageProxy::registerEditCommandForUndo(PassRefPtr<WebEditCommandProxy> commandProxy)
    1202 {
    1203     m_pageClient->registerEditCommand(commandProxy, PageClient::Undo);
    1204 }
    1205 
    1206 void WebPageProxy::registerEditCommandForRedo(PassRefPtr<WebEditCommandProxy> commandProxy)
    1207 {
    1208     m_pageClient->registerEditCommand(commandProxy, PageClient::Redo);
     907void WebPageProxy::registerEditCommand(PassRefPtr<WebEditCommandProxy> commandProxy, UndoOrRedo undoOrRedo)
     908{
     909    m_pageClient->registerEditCommand(commandProxy, undoOrRedo);
    1209910}
    1210911
    … …  
    1242943}
    1243944
    1244 void WebPageProxy::didReceiveEvent(WebEvent::Type type, bool handled)
    1245 {
     945void WebPageProxy::didValidateMenuItem(const String& commandName, bool isEnabled, int32_t state)
     946{
     947    m_pageClient->setEditCommandState(commandName, isEnabled, state);
     948}
     949
     950void WebPageProxy::didReceiveEvent(uint32_t opaqueType, bool handled)
     951{
     952    WebEvent::Type type = static_cast<WebEvent::Type>(opaqueType);
     953
    1246954    switch (type) {
    1247955        case WebEvent::MouseMove:
    … …  
    13051013}
    13061014
     1015
    13071016#if USE(ACCELERATED_COMPOSITING)
    1308 void WebPageProxy::didChangeAcceleratedCompositing(bool compositing)
     1017void WebPageProxy::didChangeAcceleratedCompositing(bool compositing, DrawingAreaBase::DrawingAreaInfo& drawingAreaInfo)
    13091018{
    13101019    if (compositing)
    … …  
    13121021    else
    13131022        didLeaveAcceleratedCompositing();
     1023
     1024    drawingAreaInfo = drawingArea()->info();
    13141025}
    13151026#endif

  • trunk/WebKit2/UIProcess/WebPageProxy.h

    r69116 r69210  
    6767class PageClient;
    6868class PlatformCertificateInfo;
     69class StringPairVector;
    6970class WebBackForwardList;
    7071class WebBackForwardListItem;
    … …  
    189190#endif
    190191
     192    enum UndoOrRedo { Undo, Redo };
    191193    void addEditCommand(WebEditCommandProxy*);
    192194    void removeEditCommand(WebEditCommandProxy*);
    193     void registerEditCommandForUndo(PassRefPtr<WebEditCommandProxy>);
    194     void registerEditCommandForRedo(PassRefPtr<WebEditCommandProxy>);
     195    void registerEditCommand(PassRefPtr<WebEditCommandProxy>, UndoOrRedo);
    195196
    196197    WebProcessProxy* process() const;
    … …  
    211212    virtual Type type() const { return APIType; }
    212213
     214    // Implemented in generated WebPageProxyMessageReceiver.cpp
     215    void didReceiveWebPageProxyMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*);
     216    CoreIPC::SyncReplyMode didReceiveSyncWebPageProxyMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*, CoreIPC::ArgumentEncoder*);
     217
    213218    void didCreateMainFrame(uint64_t frameID);
    214219    void didCreateSubFrame(uint64_t frameID);
    215220
    216     void didStartProvisionalLoadForFrame(WebFrameProxy*, const String&, APIObject*);
    217     void didReceiveServerRedirectForProvisionalLoadForFrame(WebFrameProxy*, const String&, APIObject*);
    218     void didFailProvisionalLoadForFrame(WebFrameProxy*, APIObject*);
    219     void didCommitLoadForFrame(WebFrameProxy*, const String& mimeType, const PlatformCertificateInfo&, APIObject*);
    220     void didFinishDocumentLoadForFrame(WebFrameProxy*, APIObject*);
    221     void didFinishLoadForFrame(WebFrameProxy*, APIObject*);
    222     void didFailLoadForFrame(WebFrameProxy*, APIObject*);
    223     void didReceiveTitleForFrame(WebFrameProxy*, const String&, APIObject*);
    224     void didFirstLayoutForFrame(WebFrameProxy*, APIObject*);
    225     void didFirstVisuallyNonEmptyLayoutForFrame(WebFrameProxy*, APIObject*);
    226     void didRemoveFrameFromHierarchy(WebFrameProxy*, APIObject*);
     221    void didStartProvisionalLoadForFrame(uint64_t frameID, const String&, CoreIPC::ArgumentDecoder*);
     222    void didReceiveServerRedirectForProvisionalLoadForFrame(uint64_t frameID, const String&, CoreIPC::ArgumentDecoder*);
     223    void didFailProvisionalLoadForFrame(uint64_t frameID, CoreIPC::ArgumentDecoder*);
     224    void didCommitLoadForFrame(uint64_t frameID, const String& mimeType, const PlatformCertificateInfo&, CoreIPC::ArgumentDecoder*);
     225    void didFinishDocumentLoadForFrame(uint64_t frameID, CoreIPC::ArgumentDecoder*);
     226    void didFinishLoadForFrame(uint64_t frameID, CoreIPC::ArgumentDecoder*);
     227    void didFailLoadForFrame(uint64_t frameID, CoreIPC::ArgumentDecoder*);
     228    void didReceiveTitleForFrame(uint64_t frameID, const String&, CoreIPC::ArgumentDecoder*);
     229    void didFirstLayoutForFrame(uint64_t frameID, CoreIPC::ArgumentDecoder*);
     230    void didFirstVisuallyNonEmptyLayoutForFrame(uint64_t frameID, CoreIPC::ArgumentDecoder*);
     231    void didRemoveFrameFromHierarchy(uint64_t frameID, CoreIPC::ArgumentDecoder*);
    227232    void didStartProgress();
    228233    void didChangeProgress(double);
    229234    void didFinishProgress();
    230235   
    231     void decidePolicyForNavigationAction(WebFrameProxy*, WebCore::NavigationType, WebEvent::Modifiers, WebMouseEvent::Button, const String& url, uint64_t listenerID);
    232     void decidePolicyForNewWindowAction(WebFrameProxy*, WebCore::NavigationType, WebEvent::Modifiers, WebMouseEvent::Button, const String& url, uint64_t listenerID);
    233     void decidePolicyForMIMEType(WebFrameProxy*, const String& MIMEType, const String& url, uint64_t listenerID);
    234 
    235     void willSubmitForm(WebFrameProxy* frame, WebFrameProxy* frameSource, Vector<std::pair<String, String> >& textFieldValues, APIObject* userData, uint64_t listenerID);
    236 
    237     PassRefPtr<WebPageProxy> createNewPage();
     236    void decidePolicyForNavigationAction(uint64_t frameID, uint32_t navigationType, uint32_t modifiers, int32_t mouseButton, const String& url, uint64_t listenerID);
     237    void decidePolicyForNewWindowAction(uint64_t frameID, uint32_t navigationType, uint32_t modifiers, int32_t mouseButton, const String& url, uint64_t listenerID);
     238    void decidePolicyForMIMEType(uint64_t frameID, const String& MIMEType, const String& url, uint64_t listenerID);
     239
     240    void willSubmitForm(uint64_t frameID, uint64_t sourceFrameID, const StringPairVector& textFieldValues, uint64_t listenerID, CoreIPC::ArgumentDecoder*);
     241
     242    void createNewPage(uint64_t& newPageID, WebPageCreationParameters&);
    238243    void showPage();
    239244    void closePage();
    240     void runJavaScriptAlert(WebFrameProxy*, const String&);
    241     bool runJavaScriptConfirm(WebFrameProxy* frame, const String&);
    242     String runJavaScriptPrompt(WebFrameProxy* frame, const String&, const String&);
     245    void runJavaScriptAlert(uint64_t frameID, const String&);
     246    void runJavaScriptConfirm(uint64_t frameID, const String&, bool& result);
     247    void runJavaScriptPrompt(uint64_t frameID, const String&, const String&, String& result);
    243248    void setStatusText(const String&);
    244     void mouseDidMoveOverElement(WebEvent::Modifiers, APIObject*);
    245     void contentsSizeChanged(WebFrameProxy*, const WebCore::IntSize&);
     249    void mouseDidMoveOverElement(uint32_t modifiers, CoreIPC::ArgumentDecoder*);
     250    void contentsSizeChanged(uint64_t frameID, const WebCore::IntSize&);
    246251
    247252    // Back/Forward list management
    248     void addItemToBackForwardList(WebBackForwardListItem*);
    249     void goToItemInBackForwardList(WebBackForwardListItem*);
     253    void backForwardAddItem(uint64_t itemID);
     254    void backForwardGoToItem(uint64_t itemID);
     255    void backForwardBackItem(uint64_t& itemID);
     256    void backForwardCurrentItem(uint64_t& itemID);
     257    void backForwardForwardItem(uint64_t& itemID);
     258    void backForwardItemAtIndex(int32_t index, uint64_t& itemID);
     259    void backForwardBackListCount(int32_t& count);
     260    void backForwardForwardListCount(int32_t& count);
    250261
    251262    // Undo management
    252     void registerEditCommandForUndo(uint64_t commandID, WebCore::EditAction);
     263    void registerEditCommandForUndo(uint64_t commandID, uint32_t editAction);
    253264    void clearAllEditCommands();
    254265
    … …  
    256267    void setToolTip(const String&);
    257268    void setCursor(const WebCore::Cursor&);
    258 
    259     void didReceiveEvent(WebEvent::Type, bool handled);
     269    void didValidateMenuItem(const String& commandName, bool isEnabled, int32_t state);
     270
     271    void didReceiveEvent(uint32_t opaqueType, bool handled);
    260272
    261273    void didRunJavaScriptInMainFrame(const String&, uint64_t);
    … …  
    266278
    267279#if USE(ACCELERATED_COMPOSITING)
    268     void didChangeAcceleratedCompositing(bool compositing);
     280    void didChangeAcceleratedCompositing(bool compositing, DrawingAreaBase::DrawingAreaInfo&);
    269281#endif   
    270282

  • trunk/WebKit2/UIProcess/win/WebView.cpp

    r68538 r69210  
    573573}
    574574
    575 void WebView::registerEditCommand(PassRefPtr<WebEditCommandProxy>, UndoOrRedo)
     575void WebView::registerEditCommand(PassRefPtr<WebEditCommandProxy>, WebPageProxy::UndoOrRedo)
    576576{
    577577}

  • trunk/WebKit2/UIProcess/win/WebView.h

    r68320 r69210  
    9696    virtual void toolTipChanged(const WTF::String&, const WTF::String&);
    9797    virtual void setCursor(const WebCore::Cursor&);
    98     virtual void registerEditCommand(PassRefPtr<WebEditCommandProxy>, UndoOrRedo);
     98    virtual void registerEditCommand(PassRefPtr<WebEditCommandProxy>, WebPageProxy::UndoOrRedo);
    9999    virtual void clearAllEditCommands();
    100100    virtual void setEditCommandState(const WTF::String&, bool, int);

  • trunk/WebKit2/WebKit2.pro

    r69037 r69210  
    142142WEBKIT2_GENERATED_HEADERS = \
    143143    $$OUTPUT_DIR/WebKit2/generated/WebPageMessages.h \
     144    $$OUTPUT_DIR/WebKit2/generated/WebPageProxyMessages.h \
    144145    $$OUTPUT_DIR/WebKit2/generated/WebProcessMessages.h
    145146
    146147WEBKIT2_GENERATED_SOURCES = \
    147148    $$OUTPUT_DIR/WebKit2/generated/WebPageMessageReceiver.cpp \
     149    $$OUTPUT_DIR/WebKit2/generated/WebPageProxyMessageReceiver.cpp \
    148150    $$OUTPUT_DIR/WebKit2/generated/WebProcessMessageReceiver.cpp
    149151
    … …  
    177179    Shared/CoreIPCSupport/DrawingAreaMessageKinds.h \
    178180    Shared/CoreIPCSupport/DrawingAreaProxyMessageKinds.h \
    179     Shared/CoreIPCSupport/WebPageProxyMessageKinds.h \
    180181    Shared/CacheModel.h \
    181182    Shared/DrawingAreaBase.h \
    … …  
    186187    Shared/NativeWebKeyboardEvent.h \
    187188    Shared/NotImplemented.h \
     189    Shared/StringPairVector.h \
    188190    Shared/qt/MappedMemory.h \
    189191    Shared/qt/PlatformCertificateInfo.h \

  • trunk/WebKit2/WebKit2.xcodeproj/project.pbxproj

    r69155 r69210  
    190190                BC111B5D112F629800337BAB /* WebEventFactory.h in Headers */ = {isa = PBXBuildFile; fileRef = BC111B5B112F629800337BAB /* WebEventFactory.h */; };
    191191                BC111B5E112F629800337BAB /* WebEventFactory.mm in Sources */ = {isa = PBXBuildFile; fileRef = BC111B5C112F629800337BAB /* WebEventFactory.mm */; };
    192                 BC111B64112F638300337BAB /* WebPageProxyMessageKinds.h in Headers */ = {isa = PBXBuildFile; fileRef = BC111B61112F638300337BAB /* WebPageProxyMessageKinds.h */; };
    193                 BC111B65112F638300337BAB /* WebProcessMessageKinds.h in Headers */ = {isa = PBXBuildFile; fileRef = BC111B62112F638300337BAB /* WebProcessMessageKinds.h */; };
    194192                BC131BC911726C2800B69727 /* CoreIPCMessageKinds.h in Headers */ = {isa = PBXBuildFile; fileRef = BC131BC811726C2800B69727 /* CoreIPCMessageKinds.h */; };
    195193                BC14DF77120B5B7900826C0C /* InjectedBundleScriptWorld.h in Headers */ = {isa = PBXBuildFile; fileRef = BC14DF75120B5B7900826C0C /* InjectedBundleScriptWorld.h */; };
    … …  
    352350                BCBCB0CB1215E32100DE59CA /* ImmutableDictionary.h in Headers */ = {isa = PBXBuildFile; fileRef = BCBCB0CA1215E32100DE59CA /* ImmutableDictionary.h */; };
    353351                BCBCB0CD1215E33A00DE59CA /* ImmutableDictionary.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BCBCB0CC1215E33A00DE59CA /* ImmutableDictionary.cpp */; };
     352                BCBD3914125BB1A800D2C29F /* WebPageProxyMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BCBD3912125BB1A800D2C29F /* WebPageProxyMessageReceiver.cpp */; };
     353                BCBD3915125BB1A800D2C29F /* WebPageProxyMessages.h in Headers */ = {isa = PBXBuildFile; fileRef = BCBD3913125BB1A800D2C29F /* WebPageProxyMessages.h */; };
     354                BCBD3C3B125BFA7A00D2C29F /* StringPairVector.h in Headers */ = {isa = PBXBuildFile; fileRef = BCBD3C3A125BFA7A00D2C29F /* StringPairVector.h */; };
    354355                BCC56F791159957D001CCAF9 /* MachPort.h in Headers */ = {isa = PBXBuildFile; fileRef = BCC56F771159957D001CCAF9 /* MachPort.h */; };
    355356                BCC5715B115ADAEF001CCAF9 /* WebSystemInterface.h in Headers */ = {isa = PBXBuildFile; fileRef = BCC57159115ADAEF001CCAF9 /* WebSystemInterface.h */; };
    … …  
    642643                BC111B5B112F629800337BAB /* WebEventFactory.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebEventFactory.h; sourceTree = "<group>"; };
    643644                BC111B5C112F629800337BAB /* WebEventFactory.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WebEventFactory.mm; sourceTree = "<group>"; };
    644                 BC111B61112F638300337BAB /* WebPageProxyMessageKinds.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebPageProxyMessageKinds.h; sourceTree = "<group>"; };
    645                 BC111B62112F638300337BAB /* WebProcessMessageKinds.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebProcessMessageKinds.h; sourceTree = "<group>"; };
    646645                BC131BC811726C2800B69727 /* CoreIPCMessageKinds.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CoreIPCMessageKinds.h; sourceTree = "<group>"; };
    647646                BC14DF75120B5B7900826C0C /* InjectedBundleScriptWorld.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InjectedBundleScriptWorld.h; sourceTree = "<group>"; };
    … …  
    804803                BCBCB0CA1215E32100DE59CA /* ImmutableDictionary.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ImmutableDictionary.h; sourceTree = "<group>"; };
    805804                BCBCB0CC1215E33A00DE59CA /* ImmutableDictionary.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ImmutableDictionary.cpp; sourceTree = "<group>"; };
     805                BCBD38FA125BAB9A00D2C29F /* WebPageProxy.messages.in */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = WebPageProxy.messages.in; sourceTree = "<group>"; };
     806                BCBD3912125BB1A800D2C29F /* WebPageProxyMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebPageProxyMessageReceiver.cpp; sourceTree = "<group>"; };
     807                BCBD3913125BB1A800D2C29F /* WebPageProxyMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebPageProxyMessages.h; sourceTree = "<group>"; };
     808                BCBD3C3A125BFA7A00D2C29F /* StringPairVector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StringPairVector.h; sourceTree = "<group>"; };
    806809                BCC56F771159957D001CCAF9 /* MachPort.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MachPort.h; sourceTree = "<group>"; };
    807810                BCC57159115ADAEF001CCAF9 /* WebSystemInterface.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebSystemInterface.h; sourceTree = "<group>"; };
    … …  
    11311134                                BC1DD7B1114DC396005ADAF3 /* WebCoreArgumentCoders.h */,
    11321135                                BCF50726124329AA005955AE /* WebCertificateInfo.h */,
     1136                                BCBD3C3A125BFA7A00D2C29F /* StringPairVector.h */,
    11331137                                51578B821209ECEF00A37C4A /* WebData.h */,
    11341138                                516A4A5B120A2CCD00C05B7F /* WebError.h */,
    … …  
    13311335                                BC111B0B112F5E4F00337BAB /* WebPageProxy.cpp */,
    13321336                                BC032DCB10F4389F0058C15A /* WebPageProxy.h */,
     1337                                BCBD38FA125BAB9A00D2C29F /* WebPageProxy.messages.in */,
    13331338                                BCB9F8AD1124E07700A137E0 /* WebPolicyClient.cpp */,
    13341339                                BCB9F8AE1124E07700A137E0 /* WebPolicyClient.h */,
    … …  
    14611466                                BCB28CBF120233D9007D99BC /* InjectedBundleMessageKinds.h */,
    14621467                                BCCB75C51203A1CE00222D1B /* WebContextMessageKinds.h */,
    1463                                 BC111B61112F638300337BAB /* WebPageProxyMessageKinds.h */,
    1464                                 BC111B62112F638300337BAB /* WebProcessMessageKinds.h */,
    14651468                                BCB7346D11CEE3FF00EC5002 /* WebProcessProxyMessageKinds.h */,
    14661469                        );
    … …  
    17031706                                C0CE729E1247E71D00BC0EC4 /* WebPageMessageReceiver.cpp */,
    17041707                                C0CE729F1247E71D00BC0EC4 /* WebPageMessages.h */,
     1708                                BCBD3912125BB1A800D2C29F /* WebPageProxyMessageReceiver.cpp */,
     1709                                BCBD3913125BB1A800D2C29F /* WebPageProxyMessages.h */,
    17051710                                1A043F6712514D8B00FFBFB5 /* WebProcessConnectionMessageReceiver.cpp */,
    17061711                                1A043F6812514D8B00FFBFB5 /* WebProcessConnectionMessages.h */,
    … …  
    18081813                                BCEE98C7113314D7006BCC24 /* WebPageNamespace.h in Headers */,
    18091814                                BC032DD110F4389F0058C15A /* WebPageProxy.h in Headers */,
    1810                                 BC111B64112F638300337BAB /* WebPageProxyMessageKinds.h in Headers */,
    18111815                                1A3E736111CC2659007BD539 /* WebPlatformStrategies.h in Headers */,
    18121816                                BCB9F8B01124E07700A137E0 /* WebPolicyClient.h in Headers */,
    … …  
    18161820                                1A6FA02011E1528700DB1371 /* WebProcessMain.h in Headers */,
    18171821                                BC032DD310F4389F0058C15A /* WebProcessManager.h in Headers */,
    1818                                 BC111B65112F638300337BAB /* WebProcessMessageKinds.h in Headers */,
    18191822                                BC032DD510F4389F0058C15A /* WebProcessProxy.h in Headers */,
    18201823                                BCB7346E11CEE3FF00EC5002 /* WebProcessProxyMessageKinds.h in Headers */,
    … …  
    19391942                                BC3066BF125A442100E71278 /* WebProcessMessages.h in Headers */,
    19401943                                BC306824125A6B9400E71278 /* WebProcessCreationParameters.h in Headers */,
     1944                                BCBD3915125BB1A800D2C29F /* WebPageProxyMessages.h in Headers */,
     1945                                BCBD3C3B125BFA7A00D2C29F /* StringPairVector.h in Headers */,
    19411946                        );
    19421947                        runOnlyForDeploymentPostprocessing = 0;
    … …  
    22362241                                BC3066BE125A442100E71278 /* WebProcessMessageReceiver.cpp in Sources */,
    22372242                                BC306825125A6B9400E71278 /* WebProcessCreationParameters.cpp in Sources */,
     2243                                BCBD3914125BB1A800D2C29F /* WebPageProxyMessageReceiver.cpp in Sources */,
    22382244                        );
    22392245                        runOnlyForDeploymentPostprocessing = 0;

  • trunk/WebKit2/WebProcess/WebCoreSupport/WebChromeClient.cpp

    r69029 r69210  
    3737#include "WebPage.h"
    3838#include "WebPageCreationParameters.h"
    39 #include "WebPageProxyMessageKinds.h"
     39#include "WebPageProxyMessages.h"
    4040#include "WebPopupMenu.h"
    4141#include "WebPreferencesStore.h"
    … …  
    5858}
    5959
    60 void WebChromeClient::setWindowRect(const FloatRect&)
     60void WebChromeClient::setWindowRect(const FloatRect& windowRect)
    6161{
    6262    notImplemented();
    … …  
    9999void WebChromeClient::takeFocus(FocusDirection direction)
    100100{
    101     WebProcess::shared().connection()->send(WebPageProxyMessage::TakeFocus, m_page->pageID(),
    102                                             direction == FocusDirectionForward ? true : false);
     101    WebProcess::shared().connection()->send(Messages::WebPageProxy::TakeFocus(direction == FocusDirectionForward ? true : false), m_page->pageID());
    103102}
    104103
    … …  
    112111    uint64_t newPageID = 0;
    113112    WebPageCreationParameters parameters;
    114     if (!WebProcess::shared().connection()->sendSync(WebPageProxyMessage::CreateNewPage,
    115                                                      m_page->pageID(), CoreIPC::In(),
    116                                                      CoreIPC::Out(newPageID, parameters),
    117                                                      CoreIPC::Connection::NoTimeout)) {
     113    if (!WebProcess::shared().connection()->sendSync(Messages::WebPageProxy::CreateNewPage(),
     114            Messages::WebPageProxy::CreateNewPage::Reply(newPageID, parameters),
     115            m_page->pageID(), CoreIPC::Connection::NoTimeout)) {
    118116        return 0;
    119117    }
    … …  
    237235    m_page->injectedBundleUIClient().willRunJavaScriptAlert(m_page, alertText, webFrame);
    238236
    239     WebProcess::shared().connection()->sendSync(WebPageProxyMessage::RunJavaScriptAlert, m_page->pageID(),
    240                                                 CoreIPC::In(webFrame->frameID(), alertText),
    241                                                 CoreIPC::Out(),
    242                                                 CoreIPC::Connection::NoTimeout);
     237    WebProcess::shared().connection()->sendSync(Messages::WebPageProxy::RunJavaScriptAlert(webFrame->frameID(), alertText),
     238        Messages::WebPageProxy::RunJavaScriptAlert::Reply(), m_page->pageID(), CoreIPC::Connection::NoTimeout);
    243239}
    244240
    … …  
    251247
    252248    bool result = false;
    253     if (!WebProcess::shared().connection()->sendSync(WebPageProxyMessage::RunJavaScriptConfirm, m_page->pageID(),
    254                                                      CoreIPC::In(webFrame->frameID(), message),
    255                                                      CoreIPC::Out(result),
    256                                                      CoreIPC::Connection::NoTimeout)) {
     249    if (!WebProcess::shared().connection()->sendSync(Messages::WebPageProxy::RunJavaScriptConfirm(webFrame->frameID(), message),
     250             Messages::WebPageProxy::RunJavaScriptConfirm::Reply(result), m_page->pageID(), CoreIPC::Connection::NoTimeout))
    257251        return false;
    258     }
    259252
    260253    return result;
    … …  
    268261    m_page->injectedBundleUIClient().willRunJavaScriptPrompt(m_page, message, defaultValue, webFrame);
    269262
    270     if (!WebProcess::shared().connection()->sendSync(WebPageProxyMessage::RunJavaScriptPrompt, m_page->pageID(),
    271                                                      CoreIPC::In(webFrame->frameID(), message, defaultValue),
    272                                                      CoreIPC::Out(result),
    273                                                      CoreIPC::Connection::NoTimeout)) {
     263    if (!WebProcess::shared().connection()->sendSync(Messages::WebPageProxy::RunJavaScriptPrompt(webFrame->frameID(), message, defaultValue),
     264             Messages::WebPageProxy::RunJavaScriptPrompt::Reply(result), m_page->pageID(), CoreIPC::Connection::NoTimeout))
    274265        return false;
    275     }
    276266
    277267    return !result.isNull();
    … …  
    283273    m_page->injectedBundleUIClient().willSetStatusbarText(m_page, statusbarText);
    284274
    285     WebProcess::shared().connection()->send(WebPageProxyMessage::SetStatusText, m_page->pageID(), statusbarText);
     275    WebProcess::shared().connection()->send(Messages::WebPageProxy::SetStatusText(statusbarText), m_page->pageID());
    286276}
    287277
    … …  
    344334{
    345335    WebFrame* webFrame =  static_cast<WebFrameLoaderClient*>(frame->loader()->client())->webFrame();
    346     WebProcess::shared().connection()->send(WebPageProxyMessage::ContentsSizeChanged, m_page->pageID(),
    347                                             CoreIPC::In(webFrame->frameID(), size));
     336
     337    WebProcess::shared().connection()->send(Messages::WebPageProxy::ContentsSizeChanged(webFrame->frameID(), size), m_page->pageID());
    348338}
    349339
    … …  
    366356
    367357    // Notify the UIProcess.
    368     WebProcess::shared().connection()->send(WebPageProxyMessage::MouseDidMoveOverElement, m_page->pageID(), CoreIPC::In(modifierFlags, InjectedBundleUserMessageEncoder(userData.get())));
     358    WebProcess::shared().connection()->send(Messages::WebPageProxy::MouseDidMoveOverElement(modifierFlags, InjectedBundleUserMessageEncoder(userData.get())), m_page->pageID());
    369359}
    370360
    … …  
    377367    m_cachedToolTip = toolTip;
    378368
    379     WebProcess::shared().connection()->send(WebPageProxyMessage::SetToolTip, m_page->pageID(), CoreIPC::In(m_cachedToolTip));
     369    WebProcess::shared().connection()->send(Messages::WebPageProxy::SetToolTip(m_cachedToolTip), m_page->pageID());
    380370}
    381371
    … …  
    477467{
    478468#if USE(LAZY_NATIVE_CURSOR)
    479     WebProcess::shared().connection()->send(WebPageProxyMessage::SetCursor, m_page->pageID(), CoreIPC::In(cursor));
     469    WebProcess::shared().connection()->send(Messages::WebPageProxy::SetCursor(cursor), m_page->pageID());
    480470#endif
    481471}

  • trunk/WebKit2/WebProcess/WebCoreSupport/WebEditorClient.cpp

    r67864 r69210  
    3131#include "WebFrameLoaderClient.h"
    3232#include "WebPage.h"
    33 #include "WebPageProxyMessageKinds.h"
     33#include "WebPageProxyMessages.h"
    3434#include "WebProcess.h"
    3535#include <WebCore/ArchiveResource.h>
    … …  
    212212    uint32_t editAction = static_cast<uint32_t>(webCommand->command()->editingAction());
    213213
    214     WebProcess::shared().connection()->send(WebPageProxyMessage::RegisterEditCommandForUndo, m_page->pageID(),
    215                                             CoreIPC::In(webCommand->commandID(), editAction));
     214    WebProcess::shared().connection()->send(Messages::WebPageProxy::RegisterEditCommandForUndo(webCommand->commandID(), editAction), m_page->pageID());
    216215}
    217216
    … …  
    222221void WebEditorClient::clearUndoRedoOperations()
    223222{
    224     WebProcess::shared().connection()->send(WebPageProxyMessage::ClearAllEditCommands, m_page->pageID(), CoreIPC::In());
     223    WebProcess::shared().connection()->send(Messages::WebPageProxy::ClearAllEditCommands(), m_page->pageID());
    225224}
    226225

  • trunk/WebKit2/WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp

    r69116 r69210  
    3232#include "PlatformCertificateInfo.h"
    3333#include "PluginView.h"
     34#include "StringPairVector.h"
    3435#include "WebCoreArgumentCoders.h"
    3536#include "WebErrors.h"
    … …  
    3940#include "WebNavigationDataStore.h"
    4041#include "WebPage.h"
    41 #include "WebPageProxyMessageKinds.h"
     42#include "WebPageProxyMessages.h"
    4243#include "WebProcess.h"
    4344#include "WebProcessProxyMessageKinds.h"
    … …  
    126127
    127128    // Notify the UIProcess.
    128     WebProcess::shared().connection()->send(WebPageProxyMessage::DidRemoveFrameFromHierarchy, webPage->pageID(), CoreIPC::In(m_frame->frameID(), InjectedBundleUserMessageEncoder(userData.get())));
     129    WebProcess::shared().connection()->send(Messages::WebPageProxy::DidRemoveFrameFromHierarchy(m_frame->frameID(), InjectedBundleUserMessageEncoder(userData.get())), webPage->pageID());
     130
    129131}
    130132
    … …  
    224226
    225227    // Notify the UIProcess.
    226     WebProcess::shared().connection()->send(WebPageProxyMessage::DidReceiveServerRedirectForProvisionalLoadForFrame, webPage->pageID(), CoreIPC::In(m_frame->frameID(), url, InjectedBundleUserMessageEncoder(userData.get())));
     228    WebProcess::shared().connection()->send(Messages::WebPageProxy::DidReceiveServerRedirectForProvisionalLoadForFrame(m_frame->frameID(), url, InjectedBundleUserMessageEncoder(userData.get())), webPage->pageID());
    227229}
    228230
    … …  
    296298
    297299    // Notify the UIProcess.
    298     WebProcess::shared().connection()->send(WebPageProxyMessage::DidStartProvisionalLoadForFrame, webPage->pageID(), CoreIPC::In(m_frame->frameID(), url, InjectedBundleUserMessageEncoder(userData.get())));
     300    WebProcess::shared().connection()->send(Messages::WebPageProxy::DidStartProvisionalLoadForFrame(m_frame->frameID(), url, InjectedBundleUserMessageEncoder(userData.get())), webPage->pageID());
    299301}
    300302
    … …  
    311313
    312314    // Notify the UIProcess.
    313     WebProcess::shared().connection()->send(WebPageProxyMessage::DidReceiveTitleForFrame, webPage->pageID(), CoreIPC::In(m_frame->frameID(), title, InjectedBundleUserMessageEncoder(userData.get())));
     315    WebProcess::shared().connection()->send(Messages::WebPageProxy::DidReceiveTitleForFrame(m_frame->frameID(), title, InjectedBundleUserMessageEncoder(userData.get())), webPage->pageID());
    314316}
    315317
    … …  
    332334
    333335    // Notify the UIProcess.
    334     WebProcess::shared().connection()->send(WebPageProxyMessage::DidCommitLoadForFrame, webPage->pageID(), CoreIPC::In(m_frame->frameID(), response.mimeType(), PlatformCertificateInfo(response), InjectedBundleUserMessageEncoder(userData.get())));
     336    WebProcess::shared().connection()->send(Messages::WebPageProxy::DidCommitLoadForFrame(m_frame->frameID(), response.mimeType(), PlatformCertificateInfo(response), InjectedBundleUserMessageEncoder(userData.get())), webPage->pageID());
    335337}
    336338
    … …  
    347349
    348350    // Notify the UIProcess.
    349     WebProcess::shared().connection()->send(WebPageProxyMessage::DidFailProvisionalLoadForFrame, webPage->pageID(), CoreIPC::In(m_frame->frameID(), InjectedBundleUserMessageEncoder(userData.get())));
     351    WebProcess::shared().connection()->send(Messages::WebPageProxy::DidFailProvisionalLoadForFrame(m_frame->frameID(), InjectedBundleUserMessageEncoder(userData.get())), webPage->pageID());
    350352   
    351353    // If we have a load listener, notify it.
    … …  
    366368
    367369    // Notify the UIProcess.
    368     WebProcess::shared().connection()->send(WebPageProxyMessage::DidFailLoadForFrame, webPage->pageID(), CoreIPC::In(m_frame->frameID(), InjectedBundleUserMessageEncoder(userData.get())));
     370    WebProcess::shared().connection()->send(Messages::WebPageProxy::DidFailLoadForFrame(m_frame->frameID(), InjectedBundleUserMessageEncoder(userData.get())), webPage->pageID());
    369371
    370372    // If we have a load listener, notify it.
    … …  
    385387
    386388    // Notify the UIProcess.
    387     WebProcess::shared().connection()->send(WebPageProxyMessage::DidFinishDocumentLoadForFrame, webPage->pageID(), CoreIPC::In(m_frame->frameID(), InjectedBundleUserMessageEncoder(userData.get())));
     389    WebProcess::shared().connection()->send(Messages::WebPageProxy::DidFinishDocumentLoadForFrame(m_frame->frameID(), InjectedBundleUserMessageEncoder(userData.get())), webPage->pageID());
    388390}
    389391
    … …  
    400402
    401403    // Notify the UIProcess.
    402     WebProcess::shared().connection()->send(WebPageProxyMessage::DidFinishLoadForFrame, webPage->pageID(), CoreIPC::In(m_frame->frameID(), InjectedBundleUserMessageEncoder(userData.get())));
     404    WebProcess::shared().connection()->send(Messages::WebPageProxy::DidFinishLoadForFrame(m_frame->frameID(), InjectedBundleUserMessageEncoder(userData.get())), webPage->pageID());
    403405
    404406    // If we have a load listener, notify it.
    … …  
    419421
    420422    // Notify the UIProcess.
    421     WebProcess::shared().connection()->send(WebPageProxyMessage::DidFirstLayoutForFrame, webPage->pageID(), CoreIPC::In(m_frame->frameID(), InjectedBundleUserMessageEncoder(userData.get())));
     423    WebProcess::shared().connection()->send(Messages::WebPageProxy::DidFirstLayoutForFrame(m_frame->frameID(), InjectedBundleUserMessageEncoder(userData.get())), webPage->pageID());
    422424}
    423425
    … …  
    434436
    435437    // Notify the UIProcess.
    436     WebProcess::shared().connection()->send(WebPageProxyMessage::DidFirstVisuallyNonEmptyLayoutForFrame, webPage->pageID(), CoreIPC::In(m_frame->frameID(), InjectedBundleUserMessageEncoder(userData.get())));
     438    WebProcess::shared().connection()->send(Messages::WebPageProxy::DidFirstVisuallyNonEmptyLayoutForFrame(m_frame->frameID(), InjectedBundleUserMessageEncoder(userData.get())), webPage->pageID());
    437439}
    438440
    … …  
    515517    const String& url = request.url().string(); // FIXME: Pass entire request.
    516518
    517     WebProcess::shared().connection()->send(WebPageProxyMessage::DecidePolicyForMIMEType, webPage->pageID(),
    518                                             CoreIPC::In(m_frame->frameID(), MIMEType, url, listenerID));
     519    WebProcess::shared().connection()->send(Messages::WebPageProxy::DecidePolicyForMIMEType(m_frame->frameID(), MIMEType, url, listenerID), webPage->pageID());
    519520}
    520521
    … …  
    535536    int32_t mouseButton = mouseButtonForNavigationAction(navigationAction);
    536537
    537     WebProcess::shared().connection()->send(WebPageProxyMessage::DecidePolicyForNewWindowAction, webPage->pageID(),
    538                                             CoreIPC::In(m_frame->frameID(), navigationType, modifiers, mouseButton, url, listenerID));
     538    WebProcess::shared().connection()->send(Messages::WebPageProxy::DecidePolicyForNewWindowAction(m_frame->frameID(), navigationType, modifiers, mouseButton, url, listenerID), webPage->pageID());
    539539}
    540540
    … …  
    561561    int32_t mouseButton = mouseButtonForNavigationAction(navigationAction);
    562562
    563     WebProcess::shared().connection()->send(WebPageProxyMessage::DecidePolicyForNavigationAction, webPage->pageID(),
    564                                             CoreIPC::In(m_frame->frameID(), navigationType, modifiers, mouseButton, url, listenerID));
     563    WebProcess::shared().connection()->send(Messages::WebPageProxy::DecidePolicyForNavigationAction(m_frame->frameID(), navigationType, modifiers, mouseButton, url, listenerID), webPage->pageID());
    565564}
    566565
    … …  
    593592
    594593    uint64_t listenerID = m_frame->setUpPolicyListener(function);
    595 
    596     WebProcess::shared().connection()->send(WebPageProxyMessage::WillSubmitForm, webPage->pageID(),
    597                                             CoreIPC::In(m_frame->frameID(), sourceFrame->frameID(), values, listenerID, InjectedBundleUserMessageEncoder(userData.get())));
     594    StringPairVector valuesVector(values);
     595
     596    WebProcess::shared().connection()->send(Messages::WebPageProxy::WillSubmitForm(m_frame->frameID(), sourceFrame->frameID(), valuesVector, listenerID, InjectedBundleUserMessageEncoder(userData.get())), webPage->pageID());
    598597}
    599598
    … …  
    631630{
    632631    if (WebPage* webPage = m_frame->page())
    633         WebProcess::shared().connection()->send(WebPageProxyMessage::DidStartProgress, webPage->pageID(), CoreIPC::In());
     632        WebProcess::shared().connection()->send(Messages::WebPageProxy::DidStartProgress(), webPage->pageID());
    634633}
    635634
    … …  
    638637    if (WebPage* webPage = m_frame->page()) {
    639638        double progress = webPage->corePage()->progress()->estimatedProgress();
    640         WebProcess::shared().connection()->send(WebPageProxyMessage::DidChangeProgress, webPage->pageID(), CoreIPC::In(progress));
     639        WebProcess::shared().connection()->send(Messages::WebPageProxy::DidChangeProgress(progress), webPage->pageID());
     640
    641641    }
    642642}
    … …  
    645645{
    646646    if (WebPage* webPage = m_frame->page())
    647         WebProcess::shared().connection()->send(WebPageProxyMessage::DidFinishProgress, webPage->pageID(), CoreIPC::In());
     647        WebProcess::shared().connection()->send(Messages::WebPageProxy::DidFinishProgress(), webPage->pageID());
    648648}
    649649
    … …  
    949949
    950950    // Notify the UI process that subframe has been added.
    951     WebProcess::shared().connection()->send(WebPageProxyMessage::DidCreateSubFrame, webPage->pageID(), CoreIPC::In(subframe->frameID()));
     951    WebProcess::shared().connection()->send(Messages::WebPageProxy::DidCreateSubFrame(subframe->frameID()), webPage->pageID());
    952952
    953953    Frame* coreSubframe = subframe->coreFrame();

  • trunk/WebKit2/WebProcess/WebPage/WebBackForwardListProxy.cpp

    r64918 r69210  
    2828#include "WebCoreArgumentCoders.h"
    2929#include "WebPage.h"
    30 #include "WebPageProxyMessageKinds.h"
     30#include "WebPageProxyMessages.h"
    3131#include "WebProcess.h"
    3232#include "WebProcessProxyMessageKinds.h"
    … …  
    120120    RefPtr<HistoryItem> item = prpItem;
    121121    uint64_t itemID = historyItemToIDMap().get(item);
    122     WebProcess::shared().connection()->send(WebPageProxyMessage::BackForwardAddItem, m_page->pageID(), CoreIPC::In(itemID));
     122    WebProcess::shared().connection()->send(Messages::WebPageProxy::BackForwardAddItem(itemID), m_page->pageID());
    123123}
    124124
    … …  
    136136{
    137137    uint64_t itemID = historyItemToIDMap().get(item);
    138     WebProcess::shared().connection()->send(WebPageProxyMessage::BackForwardGoToItem, m_page->pageID(), CoreIPC::In(itemID));
     138    WebProcess::shared().connection()->send(Messages::WebPageProxy::BackForwardGoToItem(itemID), m_page->pageID());
     139
    139140}
    140141
    … …  
    142143{
    143144    uint64_t backItemID = 0;
    144     if (!WebProcess::shared().connection()->sendSync(WebPageProxyMessage::BackForwardBackItem,
    145                                                      m_page->pageID(), CoreIPC::In(),
    146                                                      CoreIPC::Out(backItemID),
    147                                                      CoreIPC::Connection::NoTimeout)) {
     145    if (!WebProcess::shared().connection()->sendSync(Messages::WebPageProxy::BackForwardBackItem(),
     146             Messages::WebPageProxy::BackForwardBackItem::Reply(backItemID),
     147             m_page->pageID(), CoreIPC::Connection::NoTimeout)) {
    148148        return 0;
    149149    }
    … …  
    159159{
    160160    uint64_t currentItemID = 0;
    161     if (!WebProcess::shared().connection()->sendSync(WebPageProxyMessage::BackForwardCurrentItem,
    162                                                      m_page->pageID(), CoreIPC::In(),
    163                                                      CoreIPC::Out(currentItemID),
    164                                                      CoreIPC::Connection::NoTimeout)) {
     161    if (!WebProcess::shared().connection()->sendSync(Messages::WebPageProxy::BackForwardCurrentItem(),
     162             Messages::WebPageProxy::BackForwardCurrentItem::Reply(currentItemID),
     163             m_page->pageID(), CoreIPC::Connection::NoTimeout)) {
    165164        return 0;
    166165    }
    … …  
    176175{
    177176    uint64_t forwardItemID = 0;
    178     if (!WebProcess::shared().connection()->sendSync(WebPageProxyMessage::BackForwardForwardItem,
    179                                                      m_page->pageID(), CoreIPC::In(),
    180                                                      CoreIPC::Out(forwardItemID),
    181                                                      CoreIPC::Connection::NoTimeout)) {
     177    if (!WebProcess::shared().connection()->sendSync(Messages::WebPageProxy::BackForwardForwardItem(),
     178             Messages::WebPageProxy::BackForwardForwardItem::Reply(forwardItemID),
     179             m_page->pageID(), CoreIPC::Connection::NoTimeout)) {
    182180        return 0;
    183181    }
    … …  
    193191{
    194192    uint64_t itemID = 0;
    195     if (!WebProcess::shared().connection()->sendSync(WebPageProxyMessage::BackForwardItemAtIndex,
    196                                                      m_page->pageID(), CoreIPC::In(itemIndex),
    197                                                      CoreIPC::Out(itemID),
    198                                                      CoreIPC::Connection::NoTimeout)) {
     193    if (!WebProcess::shared().connection()->sendSync(Messages::WebPageProxy::BackForwardItemAtIndex(itemIndex),
     194             Messages::WebPageProxy::BackForwardItemAtIndex::Reply(itemID),
     195             m_page->pageID(), CoreIPC::Connection::NoTimeout)) {
    199196        return 0;
    200197    }
    … …  
    240237{
    241238    int backListCount = 0;
    242     if (!WebProcess::shared().connection()->sendSync(WebPageProxyMessage::BackForwardBackListCount,
    243                                                      m_page->pageID(), CoreIPC::In(),
    244                                                      CoreIPC::Out(backListCount),
    245                                                      CoreIPC::Connection::NoTimeout)) {
     239    if (!WebProcess::shared().connection()->sendSync(Messages::WebPageProxy::BackForwardBackListCount(),
     240             Messages::WebPageProxy::BackForwardBackListCount::Reply(backListCount),
     241             m_page->pageID(), CoreIPC::Connection::NoTimeout)) {
    246242        return 0;
    247243    }
    … …  
    253249{
    254250    int forwardListCount = 0;
    255     if (!WebProcess::shared().connection()->sendSync(WebPageProxyMessage::BackForwardForwardListCount,
    256                                                      m_page->pageID(), CoreIPC::In(),
    257                                                      CoreIPC::Out(forwardListCount),
    258                                                      CoreIPC::Connection::NoTimeout)) {
     251    if (!WebProcess::shared().connection()->sendSync(Messages::WebPageProxy::BackForwardForwardListCount(),
     252             Messages::WebPageProxy::BackForwardForwardListCount::Reply(forwardListCount),
     253             m_page->pageID(), CoreIPC::Connection::NoTimeout)) {
    259254        return 0;
    260255    }

  • trunk/WebKit2/WebProcess/WebPage/WebPage.cpp

    r68726 r69210  
    4747#include "WebInspectorClient.h"
    4848#include "WebPageCreationParameters.h"
    49 #include "WebPageProxyMessageKinds.h"
     49#include "WebPageProxyMessages.h"
    5050#include "WebProcessProxyMessageKinds.h"
    5151#include "WebPreferencesStore.h"
    … …  
    143143
    144144    m_mainFrame = WebFrame::createMainFrame(this);
    145     WebProcess::shared().connection()->send(WebPageProxyMessage::DidCreateMainFrame, m_pageID, CoreIPC::In(m_mainFrame->frameID()));
     145    WebProcess::shared().connection()->send(Messages::WebPageProxy::DidCreateMainFrame(m_mainFrame->frameID()), m_pageID);
    146146
    147147#ifndef NDEBUG
    … …  
    247247    // drawing area types.
    248248    DrawingArea::DrawingAreaInfo newDrawingAreaInfo;
    249     WebProcess::shared().connection()->sendSync(WebPageProxyMessage::DidChangeAcceleratedCompositing,
    250                                                 m_pageID, CoreIPC::In(compositing),
    251                                                 CoreIPC::Out(newDrawingAreaInfo),
    252                                                 CoreIPC::Connection::NoTimeout);
     249
     250    WebProcess::shared().connection()->sendSync(Messages::WebPageProxy::DidChangeAcceleratedCompositing(compositing),
     251        Messages::WebPageProxy::DidChangeAcceleratedCompositing::Reply(newDrawingAreaInfo),
     252        m_pageID, CoreIPC::Connection::NoTimeout);
    253253   
    254254    if (newDrawingAreaInfo.type != drawingArea()->info().type) {
    … …  
    264264{
    265265    changeAcceleratedCompositingMode(layer);
    266    
    267 #if USE(ACCELERATED_COMPOSITING)
    268266    m_drawingArea->setRootCompositingLayer(layer);
    269 #endif
    270267}
    271268
    … …  
    298295void WebPage::sendClose()
    299296{
    300     WebProcess::shared().connection()->send(WebPageProxyMessage::ClosePage, m_pageID, CoreIPC::In());
     297    WebProcess::shared().connection()->send(Messages::WebPageProxy::ClosePage(), m_pageID);
    301298}
    302299
    … …  
    482479
    483480    bool handled = handleMouseEvent(mouseEvent, m_page.get());
    484 
    485     WebProcess::shared().connection()->send(WebPageProxyMessage::DidReceiveEvent, m_pageID, CoreIPC::In(static_cast<uint32_t>(mouseEvent.type()), handled));
     481    WebProcess::shared().connection()->send(Messages::WebPageProxy::DidReceiveEvent(static_cast<uint32_t>(mouseEvent.type()), handled), m_pageID);
    486482}
    487483
    … …  
    501497
    502498    bool handled = handleWheelEvent(wheelEvent, m_page.get());
    503     WebProcess::shared().connection()->send(WebPageProxyMessage::DidReceiveEvent, m_pageID, CoreIPC::In(static_cast<uint32_t>(wheelEvent.type()), handled));
     499    WebProcess::shared().connection()->send(Messages::WebPageProxy::DidReceiveEvent(static_cast<uint32_t>(wheelEvent.type()), handled), m_pageID);
    504500}
    505501
    … …  
    520516        handled = performDefaultBehaviorForKeyEvent(keyboardEvent);
    521517
    522     WebProcess::shared().connection()->send(WebPageProxyMessage::DidReceiveEvent, m_pageID, CoreIPC::In(static_cast<uint32_t>(keyboardEvent.type()), handled));
     518    WebProcess::shared().connection()->send(Messages::WebPageProxy::DidReceiveEvent(static_cast<uint32_t>(keyboardEvent.type()), handled), m_pageID);
    523519}
    524520
    … …  
    526522{
    527523    bool isEnabled = false;
    528     int state = 0;
     524    int32_t state = 0;
    529525    Frame* frame = m_page->focusController()->focusedOrMainFrame();
    530526    if (frame) {
    … …  
    533529        isEnabled = command.isSupported() && command.isEnabled();
    534530    }
    535    
    536     WebProcess::shared().connection()->send(WebPageProxyMessage::DidValidateMenuItem, m_pageID, CoreIPC::In(commandName, isEnabled, state));
     531
     532    WebProcess::shared().connection()->send(Messages::WebPageProxy::DidValidateMenuItem(commandName, isEnabled, state), m_pageID);
    537533}
    538534
    … …  
    558554    bool handled = handleTouchEvent(touchEvent, m_page.get());
    559555
    560     WebProcess::shared().connection()->send(WebPageProxyMessage::DidReceiveEvent, m_pageID, CoreIPC::In(static_cast<uint32_t>(touchEvent.type()), handled));
     556    WebProcess::shared().connection()->send(Messages::WebPageProxy::DidReceiveEvent(static_cast<uint32_t>(touchEvent.type()), handled), m_pageID);
    561557}
    562558#endif
    … …  
    613609void WebPage::show()
    614610{
    615     WebProcess::shared().connection()->send(WebPageProxyMessage::ShowPage, m_pageID, CoreIPC::In());
     611    WebProcess::shared().connection()->send(Messages::WebPageProxy::ShowPage(), m_pageID);
    616612}
    617613
    … …  
    654650    String resultString = ustringToString(resultValue.toString(m_mainFrame->coreFrame()->script()->globalObject(mainThreadNormalWorld())->globalExec()));
    655651
    656     WebProcess::shared().connection()->send(WebPageProxyMessage::DidRunJavaScriptInMainFrame, m_pageID, CoreIPC::In(resultString, callbackID));
     652    WebProcess::shared().connection()->send(Messages::WebPageProxy::DidRunJavaScriptInMainFrame(resultString, callbackID), m_pageID);
    657653}
    658654
    … …  
    660656{
    661657    String resultString = renderTreeExternalRepresentation();
    662     WebProcess::shared().connection()->send(WebPageProxyMessage::DidGetRenderTreeExternalRepresentation, m_pageID, CoreIPC::In(resultString, callbackID));
     658    WebProcess::shared().connection()->send(Messages::WebPageProxy::DidGetRenderTreeExternalRepresentation(resultString, callbackID), m_pageID);
    663659}
    664660
    … …  
    668664    if (WebFrame* frame = WebProcess::shared().webFrame(frameID))
    669665       resultString = frame->source();
    670     WebProcess::shared().connection()->send(WebPageProxyMessage::DidGetSourceForFrame, m_pageID, CoreIPC::In(resultString, callbackID));
     666
     667    WebProcess::shared().connection()->send(Messages::WebPageProxy::DidGetSourceForFrame(resultString, callbackID), m_pageID);
    671668}
    672669

  • trunk/WebKit2/win/WebKit2.vcproj

    r69037 r69210  
    450450                        </File>
    451451                        <File
     452                                RelativePath="..\Shared\StringPairVector.h"
     453                                >
     454                        </File>
     455                        <File
    452456                                RelativePath="..\Shared\UserMessageCoders.h"
    453457                                >
    … …  
    765769                                </File>
    766770                                <File
    767                                         RelativePath="..\Shared\CoreIPCSupport\WebPageProxyMessageKinds.h"
    768                                         >
    769                                 </File>
    770                                 <File
    771771                                        RelativePath="..\Shared\CoreIPCSupport\WebProcessProxyMessageKinds.h"
    772772                                        >
    … …  
    20272027                        <File
    20282028                                RelativePath="$(WebKitOutputDir)\obj\$(ProjectName)\DerivedSources\WebPageMessages.h"
     2029                                >
     2030                        </File>
     2031                        <File
     2032                                RelativePath="$(WebKitOutputDir)\obj\$(ProjectName)\DerivedSources\WebPageProxyMessageReceiver.cpp"
     2033                                >
     2034                        </File>
     2035                        <File
     2036                                RelativePath="$(WebKitOutputDir)\obj\$(ProjectName)\DerivedSources\WebPageProxyMessages.h"
    20292037                                >
    20302038                        </File>
Note: See TracChangeset for help on using the changeset viewer.