Changeset 69329 in webkit


Ignore:
Timestamp:
Oct 7, 2010 12:32:18 PM (14 years ago)
Author:
andersca@apple.com
Message:

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

Patch by Sam Weinig <​sam@webkit.org> on 2010-10-07
Reviewed by Anders Carlsson.

  • DerivedSources.make:
  • DerivedSources.pro:
  • Platform/CoreIPC/Arguments.h:
  • Platform/CoreIPC/HandleMessage.h:

(CoreIPC::handleMessage):

  • Scripts/webkit2/messages.py:
  • Shared/CoreIPCSupport/WebPageProxyMessageKinds.h: Removed.
  • Shared/StringPairVector.h: Added.
  • UIProcess/API/mac/PageClientImpl.h:
  • UIProcess/API/mac/PageClientImpl.mm:

(WebKit::PageClientImpl::registerEditCommand):

  • UIProcess/API/qt/qwkpage.cpp:

(QWKPagePrivate::registerEditCommand):

  • UIProcess/API/qt/qwkpage_p.h:
  • UIProcess/PageClient.h:
  • UIProcess/WebEditCommandProxy.cpp:

(WebKit::WebEditCommandProxy::unapply):
(WebKit::WebEditCommandProxy::reapply):

  • UIProcess/WebFormClient.cpp:

(WebKit::WebFormClient::willSubmitForm):

  • UIProcess/WebFormClient.h:
  • UIProcess/WebPageProxy.cpp:
  • UIProcess/WebPageProxy.h:
  • UIProcess/WebPageProxy.messages.in: Added.
  • UIProcess/win/WebView.cpp:

(WebKit::WebView::registerEditCommand):

  • UIProcess/win/WebView.h:
  • WebKit2.pro:
  • WebKit2.xcodeproj/project.pbxproj:
  • WebProcess/WebCoreSupport/WebChromeClient.cpp:
  • WebProcess/WebCoreSupport/WebEditorClient.cpp:

(WebKit::WebEditorClient::registerCommandForUndo):
(WebKit::WebEditorClient::clearUndoRedoOperations):

  • WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp:
  • WebProcess/WebPage/WebBackForwardListProxy.cpp:
  • WebProcess/WebPage/WebPage.cpp:
  • win/WebKit2.vcproj:
Location:
trunk/WebKit2
Files:
1 added
27 edited
1 copied

Legend:

Unmodified
Added
Removed

  • trunk/WebKit2/ChangeLog

    r69327 r69329  
     12010-10-07  Sam Weinig  <sam@webkit.org>
     2
     3        Reviewed by Anders Carlsson.
     4
     5        Generate the messages sent to the WebPageProxy
     6        https://bugs.webkit.org/show_bug.cgi?id=47239
     7
     8        * DerivedSources.make:
     9        * DerivedSources.pro:
     10        * Platform/CoreIPC/Arguments.h:
     11        * Platform/CoreIPC/HandleMessage.h:
     12        (CoreIPC::handleMessage):
     13        * Scripts/webkit2/messages.py:
     14        * Shared/CoreIPCSupport/WebPageProxyMessageKinds.h: Removed.
     15        * Shared/StringPairVector.h: Added.
     16        * UIProcess/API/mac/PageClientImpl.h:
     17        * UIProcess/API/mac/PageClientImpl.mm:
     18        (WebKit::PageClientImpl::registerEditCommand):
     19        * UIProcess/API/qt/qwkpage.cpp:
     20        (QWKPagePrivate::registerEditCommand):
     21        * UIProcess/API/qt/qwkpage_p.h:
     22        * UIProcess/PageClient.h:
     23        * UIProcess/WebEditCommandProxy.cpp:
     24        (WebKit::WebEditCommandProxy::unapply):
     25        (WebKit::WebEditCommandProxy::reapply):
     26        * UIProcess/WebFormClient.cpp:
     27        (WebKit::WebFormClient::willSubmitForm):
     28        * UIProcess/WebFormClient.h:
     29        * UIProcess/WebPageProxy.cpp:
     30        * UIProcess/WebPageProxy.h:
     31        * UIProcess/WebPageProxy.messages.in: Added.
     32        * UIProcess/win/WebView.cpp:
     33        (WebKit::WebView::registerEditCommand):
     34        * UIProcess/win/WebView.h:
     35        * WebKit2.pro:
     36        * WebKit2.xcodeproj/project.pbxproj:
     37        * WebProcess/WebCoreSupport/WebChromeClient.cpp:
     38        * WebProcess/WebCoreSupport/WebEditorClient.cpp:
     39        (WebKit::WebEditorClient::registerCommandForUndo):
     40        (WebKit::WebEditorClient::clearUndoRedoOperations):
     41        * WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp:
     42        * WebProcess/WebPage/WebBackForwardListProxy.cpp:
     43        * WebProcess/WebPage/WebPage.cpp:
     44        * win/WebKit2.vcproj:
     45
    1462010-10-07  Brady Eidson  <beidson@apple.com>
    247

  • trunk/WebKit2/DerivedSources.make

    r69229 r69329  
    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

    r69244 r69329  
    5353QMAKE_EXTRA_TARGETS                += messagereceiver_generator
    5454
     55pageproxymessageheader_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
     56pageproxymessageheader_generator.depends  = $${SRC_ROOT_DIR}/WebKit2/Scripts/generate-messages-header.py $${SRC_ROOT_DIR}/WebKit2/UIProcess/WebPageProxy.messages.in
     57pageproxymessageheader_generator.target   = $${OUTPUT_DIR}/WebKit2/generated/WebPageProxyMessages.h
     58generated_files.depends                 += pageproxymessageheader_generator
     59QMAKE_EXTRA_TARGETS                     += pageproxymessageheader_generator
     60
     61pageproxymessagereceiver_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
     62pageproxymessagereceiver_generator.depends  = $${SRC_ROOT_DIR}/WebKit2/Scripts/generate-message-receiver.py $${SRC_ROOT_DIR}/WebKit2/UIProcess/WebPageProxy.messages.in
     63pageproxymessagereceiver_generator.target   = $${OUTPUT_DIR}/WebKit2/generated/WebPageProxyMessageReceiver.cpp
     64generated_files.depends                   += pageproxymessagereceiver_generator
     65QMAKE_EXTRA_TARGETS                       += pageproxymessagereceiver_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/HandleMessage.h

    r69245 r69329  
    33
    44namespace CoreIPC {
     5
     6// Dispatch functions with no reply arguments.
    57
    68template<typename C, typename MF>
    … …  
    5254}
    5355
     56// Dispatch functions with reply arguments.
     57
     58template<typename C, typename MF, typename R1>
     59void callMemberFunction(const Arguments0&, Arguments1<R1>& replyArgs, C* object, MF function)
     60{
     61    (object->*function)(replyArgs.argument1);
     62}
     63
     64template<typename C, typename MF, typename R1, typename R2>
     65void callMemberFunction(const Arguments0&, Arguments2<R1, R2>& replyArgs, C* object, MF function)
     66{
     67    (object->*function)(replyArgs.argument1, replyArgs.argument2);
     68}
     69
    5470template<typename C, typename MF, typename P1>
    5571void callMemberFunction(const Arguments1<P1>& args, Arguments0&, C* object, MF function)
    … …  
    6480}
    6581
     82template<typename C, typename MF, typename P1, typename P2>
     83void callMemberFunction(const Arguments2<P1, P2>& args, Arguments0&, C* object, MF function)
     84{
     85    (object->*function)(args.argument1, args.argument2);
     86}
     87
     88template<typename C, typename MF, typename P1, typename P2, typename R1>
     89void callMemberFunction(const Arguments2<P1, P2>& args, Arguments1<R1>& replyArgs, C* object, MF function)
     90{
     91    (object->*function)(args.argument1, args.argument2, replyArgs.argument1);
     92}
     93
     94template<typename C, typename MF, typename P1, typename P2, typename P3, typename R1>
     95void callMemberFunction(const Arguments3<P1, P2, P3>& args, Arguments1<R1>& replyArgs, C* object, MF function)
     96{
     97    (object->*function)(args.argument1, args.argument2, args.argument3, replyArgs.argument1);
     98}
     99
    66100template<typename C, typename MF, typename P1, typename P2, typename P3, typename P4, typename R1>
    67101void callMemberFunction(const Arguments4<P1, P2, P3, P4>& args, Arguments1<R1>& replyArgs, C* object, MF function)
    … …  
    70104}
    71105
     106// Variadic dispatch functions.
     107
     108template<typename C, typename MF>
     109void callMemberFunction(const Arguments0&, ArgumentDecoder* argumentDecoder, C* object, MF function)
     110{
     111    (object->*function)(argumentDecoder);
     112}
     113
     114template<typename C, typename MF, typename P1>
     115void callMemberFunction(const Arguments1<P1>& args, ArgumentDecoder* argumentDecoder, C* object, MF function)
     116{
     117    (object->*function)(args.argument1, argumentDecoder);
     118}
     119
     120template<typename C, typename MF, typename P1, typename P2>
     121void callMemberFunction(const Arguments2<P1, P2>& args, ArgumentDecoder* argumentDecoder, C* object, MF function)
     122{
     123    (object->*function)(args.argument1, args.argument2, argumentDecoder);
     124}
     125
     126template<typename C, typename MF, typename P1, typename P2, typename P3>
     127void callMemberFunction(const Arguments3<P1, P2, P3>& args, ArgumentDecoder* argumentDecoder, C* object, MF function)
     128{
     129    (object->*function)(args.argument1, args.argument2, args.argument3, argumentDecoder);
     130}
     131
     132template<typename C, typename MF, typename P1, typename P2, typename P3, typename P4>
     133void callMemberFunction(const Arguments4<P1, P2, P3, P4>& args, ArgumentDecoder* argumentDecoder, C* object, MF function)
     134{
     135    (object->*function)(args.argument1, args.argument2, args.argument3, args.argument4, argumentDecoder);
     136}
     137
     138template<typename C, typename MF, typename P1, typename P2, typename P3, typename P4, typename P5>
     139void callMemberFunction(const Arguments5<P1, P2, P3, P4, P5>& args, ArgumentDecoder* argumentDecoder, C* object, MF function)
     140{
     141    (object->*function)(args.argument1, args.argument2, args.argument3, args.argument4, args.argument5, argumentDecoder);
     142}
     143   
     144template<typename C, typename MF, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
     145void callMemberFunction(const Arguments6<P1, P2, P3, P4, P5, P6>& args, ArgumentDecoder* argumentDecoder, C* object, MF function)
     146{
     147    (object->*function)(args.argument1, args.argument2, args.argument3, args.argument4, args.argument5, args.argument6, argumentDecoder);
     148}
     149
     150
     151// Main dispatch functions
     152
    72153template<typename T, typename C, typename MF>
    73154void handleMessage(ArgumentDecoder* argumentDecoder, C* object, MF function)
    74155{
    75     typename T::ValueType arguments;
     156    typename T::DecodeType::ValueType arguments;
    76157    if (!argumentDecoder->decode(arguments))
    77158        return;
    … …  
    82163void handleMessage(ArgumentDecoder* argumentDecoder, ArgumentEncoder* replyEncoder, C* object, MF function)
    83164{
    84     typename T::ValueType arguments;
     165    typename T::DecodeType::ValueType arguments;
    85166    if (!argumentDecoder->decode(arguments))
    86167        return;
    … …  
    91172}
    92173
     174template<typename T, typename C, typename MF>
     175void handleMessageVariadic(ArgumentDecoder* argumentDecoder, C* object, MF function)
     176{
     177    typename T::DecodeType::ValueType arguments;
     178    if (!argumentDecoder->decode(arguments))
     179        return;
     180    callMemberFunction(arguments, argumentDecoder, object, function);
     181}
     182
    93183} // namespace CoreIPC
    94184

  • trunk/WebKit2/Platform/CoreIPC/qt/ConnectionQt.cpp

    r68788 r69329  
    2929#include "ArgumentEncoder.h"
    3030#include "ProcessLauncher.h"
    31 #include "WebPageProxyMessageKinds.h"
    3231#include "WorkItem.h"
    3332#include <QApplication>

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

    r69240 r69329  
    5858    def iterparameters(self):
    5959        return (parameter for message in self.messages for parameter in message.parameters)
     60
     61    def iterreplyparameters(self):
     62        return (reply_parameter for message in self.messages for reply_parameter in message.reply_parameters)
    6063
    6164    @classmethod
    … …  
    108111            self.delayed = delayed
    109112        self.condition = condition
     113        if len(self.parameters) != 0:
     114            self.is_variadic = parameter_type_is_variadic(self.parameters[-1].type)
     115        else:
     116            self.is_variadic = False
    110117
    111118    def id(self):
    … …  
    140147    return ''.join(result)
    141148
     149
     150def parameter_type_is_variadic(type):
     151    variadic_types = frozenset([
     152        'WebKit::InjectedBundleUserMessageEncoder',
     153    ])
     154
     155    return type in variadic_types
    142156
    143157def function_parameter_type(type):
    … …  
    151165        'uint32_t',
    152166        'uint64_t',
     167        'int8_t',
     168        'int16_t',
     169        'int32_t',
     170        'int64_t',
    153171    ])
    154172
    … …  
    176194def reply_type(message):
    177195    return arguments_type(message.reply_parameters, reply_parameter_type)
     196
     197
     198def decode_type(message):
     199    if message.is_variadic:
     200        return arguments_type(message.parameters[:-1], reply_parameter_type)
     201    return base_class(message)
    178202
    179203
    … …  
    190214    if message.reply_parameters != None:
    191215        result.append('    typedef %s Reply;\n' % reply_type(message))
     216
     217    result.append('    typedef %s DecodeType;\n' % decode_type(message))
    192218    if len(function_parameters):
    193219        result.append('    %s%s(%s)' % (len(function_parameters) == 1 and 'explicit ' or '', message.name, ', '.join([' '.join(x) for x in function_parameters])))
    … …  
    300326
    301327def async_case_statement(receiver, message):
     328    dispatch_function = 'handleMessage'
     329    if message.is_variadic:
     330        dispatch_function += 'Variadic'
     331
    302332    result = []
    303333    result.append('    case Messages::%s::%s:\n' % (receiver.name, message.id()))
    304     result.append('        CoreIPC::handleMessage<Messages::%s::%s>(arguments, this, &%s);\n' % (receiver.name, message.name, handler_function(receiver, message)))
     334    result.append('        CoreIPC::%s<Messages::%s::%s>(arguments, this, &%s);\n' % (dispatch_function, receiver.name, message.name, handler_function(receiver, message)))
    305335    result.append('        return;\n')
    306336    return surround_in_condition(''.join(result), message.condition)
    … …  
    325355    special_cases = {
    326356        'WTF::String': '"ArgumentCoders.h"',
     357        'WebKit::InjectedBundleUserMessageEncoder': '"InjectedBundleUserMessageCoders.h"',
    327358    }
    328359
    … …  
    383414        type_headers = headers_for_type(type)
    384415        headers.update(type_headers)
     416
     417    for message in receiver.messages:
     418        if message.reply_parameters is not None:
     419            for reply_parameter in message.reply_parameters:
     420                type = reply_parameter.type
     421                argument_encoder_headers = argument_coder_headers_for_type(type)
     422                if argument_encoder_headers:
     423                    headers.update(argument_encoder_headers)
     424                    continue
     425
     426                type_headers = headers_for_type(type)
     427                headers.update(type_headers)
    385428
    386429    result = []

  • trunk/WebKit2/Shared/CoreIPCSupport/WebPageProxyMessageKinds.h

    r69229 r69329  
    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 
    26 #ifndef WebPageProxyMessageKinds_h
    27 #define WebPageProxyMessageKinds_h
    28 
    29 #include "MessageID.h"
    30 
    31 // Messages sent from the web process to the WebPageProxy.
    32 
    33 namespace WebPageProxyMessage {
    34 
    35 enum Kind {
    36     CreateNewPage,
    37     ShowPage,
    38     RunJavaScriptAlert,
    39     RunJavaScriptConfirm,
    40     RunJavaScriptPrompt,
    41 
    42     ClosePage,
    43     ContentsSizeChanged,
    44     DecidePolicyForMIMEType,
    45     DecidePolicyForNavigationAction,
    46     DecidePolicyForNewWindowAction,
    47     DidChangeProgress,
    48     DidCommitLoadForFrame,
    49     DidCreateMainFrame,
    50     DidCreateSubFrame,
    51     DidFailLoadForFrame,
    52     DidFailProvisionalLoadForFrame,
    53     DidFinishDocumentLoadForFrame,
    54     DidFinishLoadForFrame,
    55     DidFinishProgress,
    56     DidFirstLayoutForFrame,
    57     DidFirstVisuallyNonEmptyLayoutForFrame,
    58     DidGetRenderTreeExternalRepresentation,
    59     DidGetSourceForFrame,
    60     DidReceiveEvent,
    61     DidReceiveServerRedirectForProvisionalLoadForFrame,
    62     DidReceiveTitleForFrame,
    63     DidRemoveFrameFromHierarchy,
    64     DidRunJavaScriptInMainFrame,
    65     DidSetFrame,
    66     DidStartProgress,
    67     DidStartProvisionalLoadForFrame,
    68     DidValidateMenuItem,
    69     MouseDidMoveOverElement,
    70     SetCursor,
    71     SetStatusText,
    72     SetToolTip,
    73     TakeFocus,
    74     WillSubmitForm,
    75 
    76     BackForwardAddItem,
    77     BackForwardGoToItem,
    78     BackForwardBackItem,
    79     BackForwardCurrentItem,
    80     BackForwardForwardItem,
    81     BackForwardItemAtIndex,
    82     BackForwardBackListCount,
    83     BackForwardForwardListCount,
    84 
    85     RegisterEditCommandForUndo,
    86     ClearAllEditCommands,
    87 
    88 #if USE(ACCELERATED_COMPOSITING)
    89     DidChangeAcceleratedCompositing,
    90 #endif
    91 };
    92 
    93 }
    94 
    95 namespace CoreIPC {
    96 
    97 template<> struct MessageKindTraits<WebPageProxyMessage::Kind> {
    98     static const MessageClass messageClass = MessageClassWebPageProxy;
    99 };
    100 
    101 }
    102 
    103 #endif // WebPageProxyMessageKinds_h

  • trunk/WebKit2/Shared/StringPairVector.h

    r69327 r69329  
    2424 */
    2525
    26 #ifndef WebFormClient_h
    27 #define WebFormClient_h
     26#ifndef StringPairVector_h
     27#define StringPairVector_h
    2828
    29 #include "WKPage.h"
    30 #include <utility>
    31 #include <wtf/Forward.h>
     29#include "ArgumentCoders.h"
    3230#include <wtf/Vector.h>
     31#include <wtf/text/WTFString.h>
    3332
    3433namespace WebKit {
    3534
    36 class APIObject;
    37 class WebPageProxy;
    38 class WebFrameProxy;
    39 class WebFormSubmissionListenerProxy;
     35// This class is a hack to work around the fact that the IPC message generator
     36// cannot deal with class templates with more than one paramter.
     37class StringPairVector {
     38public:
     39    StringPairVector()
     40    {
     41    }
    4042
    41 class WebFormClient {
    42 public:
    43     WebFormClient();
    44     void initialize(const WKPageFormClient*);
     43    StringPairVector(Vector<std::pair<String, String> > stringPairVector)
     44    {
     45        m_stringPairVector.swap(stringPairVector);
     46    }
    4547
    46     bool willSubmitForm(WebPageProxy*, WebFrameProxy*, WebFrameProxy*, Vector<std::pair<String, String> >& textFieldValues, APIObject* userData, WebFormSubmissionListenerProxy*);
     48    void encode(CoreIPC::ArgumentEncoder* encoder) const
     49    {
     50        encoder->encode(m_stringPairVector);
     51    }
     52
     53    static bool decode(CoreIPC::ArgumentDecoder* decoder, StringPairVector& stringPairVector)
     54    {
     55        return decoder->decode(stringPairVector.m_stringPairVector);
     56    }
     57
     58    const Vector<std::pair<String, String> >& stringPairVector() const { return m_stringPairVector; }
    4759
    4860private:
    49     WKPageFormClient m_pageFormClient;
     61    Vector<std::pair<String, String> > m_stringPairVector;
    5062};
    5163
    5264} // namespace WebKit
    5365
    54 #endif // WebFormClient_h
     66#endif // StringPairVector_h

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

    r69229 r69329  
    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

    r69229 r69329  
    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

    r69316 r69329  
    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

    r69229 r69329  
    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>, WebKit::WebPageProxy::UndoOrRedo);
    5757    virtual void clearAllEditCommands();
    5858

  • trunk/WebKit2/UIProcess/PageClient.h

    r69229 r69329  
    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

    r69229 r69329  
    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

    r69229 r69329  
    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

    r69229 r69329  
    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

    r69325 r69329  
    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"
    … …  
    556556    }
    557557
    558     switch (messageID.get<WebPageProxyMessage::Kind>()) {
    559         case WebPageProxyMessage::DidCreateMainFrame: {
    560             uint64_t frameID;
    561             if (!arguments->decode(frameID))
    562                 return;
    563             didCreateMainFrame(frameID);
    564             break;
    565         }
    566         case WebPageProxyMessage::DidCreateSubFrame: {
    567             uint64_t frameID;
    568             if (!arguments->decode(frameID))
    569                 return;
    570             didCreateSubFrame(frameID);
    571             break;
    572         }
    573         case WebPageProxyMessage::DidStartProvisionalLoadForFrame: {
    574             uint64_t frameID;
    575             String url;
    576 
    577             RefPtr<APIObject> userData;
    578             WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
    579 
    580             if (!arguments->decode(CoreIPC::Out(frameID, url, messageDecoder)))
    581                 return;
    582 
    583             didStartProvisionalLoadForFrame(process()->webFrame(frameID), url, userData.get());
    584             break;
    585         }
    586         case WebPageProxyMessage::DidReceiveServerRedirectForProvisionalLoadForFrame: {
    587             uint64_t frameID;
    588             String url;
    589 
    590             RefPtr<APIObject> userData;
    591             WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
    592 
    593             if (!arguments->decode(CoreIPC::Out(frameID, url, messageDecoder)))
    594                 return;
    595 
    596             didReceiveServerRedirectForProvisionalLoadForFrame(process()->webFrame(frameID), url, userData.get());
    597             break;
    598         }
    599         case WebPageProxyMessage::DidFailProvisionalLoadForFrame: {
    600             uint64_t frameID;
    601            
    602             RefPtr<APIObject> userData;
    603             WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
    604 
    605             if (!arguments->decode(CoreIPC::Out(frameID, messageDecoder)))
    606                 return;
    607 
    608             didFailProvisionalLoadForFrame(process()->webFrame(frameID), userData.get());
    609             break;
    610         }
    611         case WebPageProxyMessage::DidCommitLoadForFrame: {
    612             uint64_t frameID;
    613             String mimeType;
    614             PlatformCertificateInfo certificateInfo;
    615 
    616             RefPtr<APIObject> userData;
    617             WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
    618 
    619             if (!arguments->decode(CoreIPC::Out(frameID, mimeType, certificateInfo, messageDecoder)))
    620                 return;
    621    
    622             didCommitLoadForFrame(process()->webFrame(frameID), mimeType, certificateInfo, userData.get());
    623             break;
    624         }
    625         case WebPageProxyMessage::DidFinishDocumentLoadForFrame: {
    626             uint64_t frameID;
    627 
    628             RefPtr<APIObject> userData;
    629             WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
    630 
    631             if (!arguments->decode(CoreIPC::Out(frameID, messageDecoder)))
    632                 return;
    633 
    634             didFinishDocumentLoadForFrame(process()->webFrame(frameID), userData.get());
    635             break;
    636         }
    637         case WebPageProxyMessage::DidFinishLoadForFrame: {
    638             uint64_t frameID;
    639 
    640             RefPtr<APIObject> userData;
    641             WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
    642 
    643             if (!arguments->decode(CoreIPC::Out(frameID, messageDecoder)))
    644                 return;
    645 
    646             didFinishLoadForFrame(process()->webFrame(frameID), userData.get());
    647             break;
    648         }
    649         case WebPageProxyMessage::DidFailLoadForFrame: {
    650             uint64_t frameID;
    651 
    652             RefPtr<APIObject> userData;
    653             WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
    654 
    655             if (!arguments->decode(CoreIPC::Out(frameID, messageDecoder)))
    656                 return;
    657 
    658             didFailLoadForFrame(process()->webFrame(frameID), userData.get());
    659             break;
    660         }
    661         case WebPageProxyMessage::DidReceiveTitleForFrame: {
    662             uint64_t frameID;
    663             String title;
    664 
    665             RefPtr<APIObject> userData;
    666             WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
    667 
    668             if (!arguments->decode(CoreIPC::Out(frameID, title, messageDecoder)))
    669                 return;
    670 
    671             didReceiveTitleForFrame(process()->webFrame(frameID), title, userData.get());
    672             break;
    673         }
    674         case WebPageProxyMessage::DidFirstLayoutForFrame: {
    675             uint64_t frameID;
    676 
    677             RefPtr<APIObject> userData;
    678             WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
    679 
    680             if (!arguments->decode(CoreIPC::Out(frameID, messageDecoder)))
    681                 return;
    682 
    683             didFirstLayoutForFrame(process()->webFrame(frameID), userData.get());
    684             break;
    685         }
    686         case WebPageProxyMessage::DidFirstVisuallyNonEmptyLayoutForFrame: {
    687             uint64_t frameID;
    688 
    689             RefPtr<APIObject> userData;
    690             WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
    691 
    692             if (!arguments->decode(CoreIPC::Out(frameID, messageDecoder)))
    693                 return;
    694 
    695             didFirstVisuallyNonEmptyLayoutForFrame(process()->webFrame(frameID), userData.get());
    696             break;
    697         }
    698         case WebPageProxyMessage::DidRemoveFrameFromHierarchy: {
    699             uint64_t frameID;
    700 
    701             RefPtr<APIObject> userData;
    702             WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
    703 
    704             if (!arguments->decode(CoreIPC::Out(frameID, messageDecoder)))
    705                 return;
    706 
    707             didRemoveFrameFromHierarchy(process()->webFrame(frameID), userData.get());
    708             break;
    709         }
    710         case WebPageProxyMessage::DidStartProgress:
    711             didStartProgress();
    712             break;
    713         case WebPageProxyMessage::DidChangeProgress: {
    714             double value;
    715             if (!arguments->decode(value))
    716                 return;
    717             didChangeProgress(value);
    718             break;
    719         }
    720         case WebPageProxyMessage::DidFinishProgress:
    721             didFinishProgress();
    722             break;
    723         case WebPageProxyMessage::DidReceiveEvent: {
    724             uint32_t type;
    725             bool handled;
    726             if (!arguments->decode(CoreIPC::Out(type, handled)))
    727                 return;
    728             didReceiveEvent((WebEvent::Type)type, handled);
    729             break;
    730         }
    731         case WebPageProxyMessage::TakeFocus: {
    732             // FIXME: Use enum here.
    733             bool direction;
    734             if (!arguments->decode(direction))
    735                 return;
    736             takeFocus(direction);
    737             break;
    738         }
    739         case WebPageProxyMessage::DecidePolicyForNavigationAction: {
    740             uint64_t frameID;
    741             uint32_t navigationType;
    742             uint32_t modifiers;
    743             int32_t mouseButton;
    744             String url;
    745             uint64_t listenerID;
    746             if (!arguments->decode(CoreIPC::Out(frameID, navigationType, modifiers, mouseButton, url, listenerID)))
    747                 return;
    748             decidePolicyForNavigationAction(process()->webFrame(frameID), static_cast<NavigationType>(navigationType), static_cast<WebEvent::Modifiers>(modifiers), static_cast<WebMouseEvent::Button>(mouseButton), url, listenerID);
    749             break;
    750         }
    751         case WebPageProxyMessage::DecidePolicyForNewWindowAction: {
    752             uint64_t frameID;
    753             uint32_t navigationType;
    754             uint32_t modifiers;
    755             int32_t mouseButton;
    756             String url;
    757             uint64_t listenerID;
    758             if (!arguments->decode(CoreIPC::Out(frameID, navigationType, modifiers, mouseButton, url, listenerID)))
    759                 return;
    760             decidePolicyForNewWindowAction(process()->webFrame(frameID), static_cast<NavigationType>(navigationType), static_cast<WebEvent::Modifiers>(modifiers), static_cast<WebMouseEvent::Button>(mouseButton), url, listenerID);
    761             break;
    762         }
    763         case WebPageProxyMessage::DecidePolicyForMIMEType: {
    764             uint64_t frameID;
    765             String MIMEType;
    766             String url;
    767             uint64_t listenerID;
    768             if (!arguments->decode(CoreIPC::Out(frameID, MIMEType, url, listenerID)))
    769                 return;
    770             decidePolicyForMIMEType(process()->webFrame(frameID), MIMEType, url, listenerID);
    771             break;
    772         }
    773         case WebPageProxyMessage::WillSubmitForm: {
    774             uint64_t frameID;
    775             uint64_t sourceFrameID;
    776             Vector<std::pair<String, String> > textFieldValues;
    777             uint64_t listenerID;
    778 
    779             RefPtr<APIObject> userData;
    780             WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
    781 
    782             if (!arguments->decode(CoreIPC::Out(frameID, sourceFrameID, textFieldValues, listenerID, messageDecoder)))
    783                 return;
    784 
    785             willSubmitForm(process()->webFrame(frameID), process()->webFrame(sourceFrameID), textFieldValues, userData.get(), listenerID);
    786             break;
    787         }
    788         case WebPageProxyMessage::DidRunJavaScriptInMainFrame: {
    789             String resultString;
    790             uint64_t callbackID;
    791             if (!arguments->decode(CoreIPC::Out(resultString, callbackID)))
    792                 return;
    793             didRunJavaScriptInMainFrame(resultString, callbackID);
    794             break;
    795         }
    796         case WebPageProxyMessage::DidGetRenderTreeExternalRepresentation: {
    797             String resultString;
    798             uint64_t callbackID;
    799             if (!arguments->decode(CoreIPC::Out(resultString, callbackID)))
    800                 return;
    801             didGetRenderTreeExternalRepresentation(resultString, callbackID);
    802             break;
    803         }
    804         case WebPageProxyMessage::DidGetSourceForFrame: {
    805             String resultString;
    806             uint64_t callbackID;
    807             if (!arguments->decode(CoreIPC::Out(resultString, callbackID)))
    808                 return;
    809             didGetSourceForFrame(resultString, callbackID);
    810             break;
    811         }
    812         case WebPageProxyMessage::SetToolTip: {
    813             String toolTip;
    814             if (!arguments->decode(toolTip))
    815                 return;
    816             setToolTip(toolTip);
    817             break;
    818         }
    819         case WebPageProxyMessage::SetCursor: {
    820 #if USE(LAZY_NATIVE_CURSOR)
    821             Cursor cursor;
    822             if (!arguments->decode(cursor))
    823                 return;
    824             setCursor(cursor);
    825 #endif
    826             break;
    827         }
    828         case WebPageProxyMessage::ShowPage: {
    829             showPage();
    830             break;
    831         }
    832         case WebPageProxyMessage::ClosePage: {
    833             closePage();
    834             break;
    835         }
    836         case WebPageProxyMessage::BackForwardAddItem: {
    837             uint64_t itemID;
    838             if (!arguments->decode(CoreIPC::Out(itemID)))
    839                 return;
    840             addItemToBackForwardList(process()->webBackForwardItem(itemID));
    841             break;
    842         }
    843         case WebPageProxyMessage::BackForwardGoToItem: {
    844             uint64_t itemID;
    845             if (!arguments->decode(CoreIPC::Out(itemID)))
    846                 return;
    847             goToItemInBackForwardList(process()->webBackForwardItem(itemID));
    848             break;
    849         }
    850         case WebPageProxyMessage::ContentsSizeChanged: {
    851             IntSize size;
    852             uint64_t frameID;
    853             if (!arguments->decode(CoreIPC::Out(frameID, size)))
    854                 return;
    855             contentsSizeChanged(process()->webFrame(frameID), size);
    856             break;
    857         }
    858         case WebPageProxyMessage::SetStatusText: {
    859             String text;
    860             if (!arguments->decode(CoreIPC::Out(text)))
    861                 return;
    862             setStatusText(text);
    863             break;
    864         }
    865         case WebPageProxyMessage::RegisterEditCommandForUndo: {
    866             uint64_t commandID;
    867             uint32_t editAction;
    868             if (!arguments->decode(CoreIPC::Out(commandID, editAction)))
    869                 return;
    870                
    871             registerEditCommandForUndo(commandID, static_cast<EditAction>(editAction));
    872             break;
    873         }
    874         case WebPageProxyMessage::ClearAllEditCommands:
    875             clearAllEditCommands();
    876             break;
    877         case WebPageProxyMessage::DidValidateMenuItem: {
    878             int state;
    879             bool isEnabled;
    880             String commandName;
    881             if (!arguments->decode(CoreIPC::Out(commandName, isEnabled, state)))
    882                 return;
    883             m_pageClient->setEditCommandState(commandName, isEnabled, state);
    884             break;
    885         }
    886         case WebPageProxyMessage::MouseDidMoveOverElement: {
    887             uint32_t modifiers;
    888             RefPtr<APIObject> userData;
    889             WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
    890 
    891             if (!arguments->decode(CoreIPC::Out(modifiers, messageDecoder)))
    892                 return;
    893 
    894             mouseDidMoveOverElement(static_cast<WebEvent::Modifiers>(modifiers), userData.get());
    895             break;
    896         }
    897         default:
    898             ASSERT_NOT_REACHED();
    899             break;
    900     }
     558    didReceiveWebPageProxyMessage(connection, messageID, arguments);
     559
    901560}
    902561
    … …  
    908567    }
    909568
    910     switch (messageID.get<WebPageProxyMessage::Kind>()) {
    911         case WebPageProxyMessage::CreateNewPage: {
    912             RefPtr<WebPageProxy> newPage = createNewPage();
    913             WebPageCreationParameters parameters;
    914             if (newPage) {
    915                 // FIXME: Pass the real size.
    916                 parameters = newPage->creationParameters(IntSize(100, 100));
    917                 reply->encode(CoreIPC::In(newPage->pageID(), parameters));
    918             } else {
    919                 reply->encode(CoreIPC::In(static_cast<uint64_t>(0), parameters));
    920             }
    921             break;
    922         }
    923         case WebPageProxyMessage::RunJavaScriptAlert: {
    924             uint64_t frameID;
    925             String message;
    926             if (!arguments->decode(CoreIPC::Out(frameID, message)))
    927                 return;
    928             runJavaScriptAlert(process()->webFrame(frameID), message);
    929             break;
    930         }
    931         case WebPageProxyMessage::RunJavaScriptConfirm: {
    932             // FIXME: We should probably encode something in the case that the arguments do not decode correctly.
    933             uint64_t frameID;
    934             String message;
    935             if (!arguments->decode(CoreIPC::Out(frameID, message)))
    936                 return;
    937 
    938             bool result = runJavaScriptConfirm(process()->webFrame(frameID), message);
    939             reply->encode(CoreIPC::In(result));
    940             break;
    941         }
    942         case WebPageProxyMessage::RunJavaScriptPrompt: {
    943             // FIXME: We should probably encode something in the case that the arguments do not decode correctly.
    944             uint64_t frameID;
    945             String message;
    946             String defaultValue;
    947             if (!arguments->decode(CoreIPC::Out(frameID, message, defaultValue)))
    948                 return;
    949 
    950             String result = runJavaScriptPrompt(process()->webFrame(frameID), message, defaultValue);
    951             reply->encode(CoreIPC::In(result));
    952             break;
    953         }
    954 
    955         case WebPageProxyMessage::BackForwardBackItem: {
    956             WebBackForwardListItem* backItem = m_backForwardList->backItem();
    957             uint64_t backItemID = backItem ? backItem->itemID() : 0;
    958             reply->encode(CoreIPC::In(backItemID));
    959             break;
    960         }
    961         case WebPageProxyMessage::BackForwardCurrentItem: {
    962             WebBackForwardListItem* currentItem = m_backForwardList->currentItem();
    963             uint64_t currentItemID = currentItem ? currentItem->itemID() : 0;
    964             reply->encode(CoreIPC::In(currentItemID));
    965             break;
    966         }
    967         case WebPageProxyMessage::BackForwardForwardItem: {
    968             WebBackForwardListItem* forwardItem = m_backForwardList->forwardItem();
    969             uint64_t forwardItemID = forwardItem ? forwardItem->itemID() : 0;
    970             reply->encode(CoreIPC::In(forwardItemID));
    971             break;
    972         }
    973         case WebPageProxyMessage::BackForwardItemAtIndex: {
    974             int itemIndex;
    975             if (!arguments->decode(CoreIPC::Out(itemIndex)))
    976                 return;
    977 
    978             WebBackForwardListItem* item = m_backForwardList->itemAtIndex(itemIndex);
    979             uint64_t itemID = item ? item->itemID() : 0;
    980             reply->encode(CoreIPC::In(itemID));
    981             break;
    982         }
    983         case WebPageProxyMessage::BackForwardBackListCount: {
    984             int backListCount = m_backForwardList->backListCount();
    985             reply->encode(CoreIPC::In(backListCount));
    986             break;
    987         }
    988         case WebPageProxyMessage::BackForwardForwardListCount: {
    989             int forwardListCount = m_backForwardList->forwardListCount();
    990             reply->encode(CoreIPC::In(forwardListCount));
    991             break;
    992         }
    993 #if USE(ACCELERATED_COMPOSITING)
    994         case WebPageProxyMessage::DidChangeAcceleratedCompositing: {
    995             bool compositing;
    996             if (!arguments->decode(CoreIPC::Out(compositing)))
    997                 return;
    998 
    999             didChangeAcceleratedCompositing(compositing);
    1000             reply->encode(drawingArea()->info());
    1001             break;
    1002         }
    1003 #endif // USE(ACCELERATED_COMPOSITING)
    1004 
    1005         default:
    1006             ASSERT_NOT_REACHED();
    1007             break;
    1008     }
     569    // FIXME: Do something with reply.
     570    didReceiveSyncWebPageProxyMessage(connection, messageID, arguments, reply);
    1009571}
    1010572
    … …  
    1044606}
    1045607
    1046 void WebPageProxy::didStartProvisionalLoadForFrame(WebFrameProxy* frame, const String& url, APIObject* userData)
    1047 {
     608void WebPageProxy::didStartProvisionalLoadForFrame(uint64_t frameID, const String& url, CoreIPC::ArgumentDecoder* arguments)
     609{
     610    RefPtr<APIObject> userData;
     611    WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
     612    if (!arguments->decode(messageDecoder))
     613        return;
     614
     615    WebFrameProxy* frame = process()->webFrame(frameID);
     616
    1048617    frame->didStartProvisionalLoad(url);
    1049     m_loaderClient.didStartProvisionalLoadForFrame(this, frame, userData);
    1050 }
    1051 
    1052 void WebPageProxy::didReceiveServerRedirectForProvisionalLoadForFrame(WebFrameProxy* frame, const String& url, APIObject* userData)
    1053 {
     618    m_loaderClient.didStartProvisionalLoadForFrame(this, frame, userData.get());
     619}
     620
     621void WebPageProxy::didReceiveServerRedirectForProvisionalLoadForFrame(uint64_t frameID, const String& url, CoreIPC::ArgumentDecoder* arguments)
     622{
     623    RefPtr<APIObject> userData;
     624    WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
     625    if (!arguments->decode(messageDecoder))
     626        return;
     627
     628    WebFrameProxy* frame = process()->webFrame(frameID);
     629
    1054630    frame->didReceiveServerRedirectForProvisionalLoad(url);
    1055     m_loaderClient.didReceiveServerRedirectForProvisionalLoadForFrame(this, frame, userData);
    1056 }
    1057 
    1058 void WebPageProxy::didFailProvisionalLoadForFrame(WebFrameProxy* frame, APIObject* userData)
    1059 {
    1060     m_loaderClient.didFailProvisionalLoadWithErrorForFrame(this, frame, userData);
    1061 }
    1062 
    1063 void WebPageProxy::didCommitLoadForFrame(WebFrameProxy* frame, const String& mimeType, const PlatformCertificateInfo& certificateInfo, APIObject* userData)
    1064 {
     631    m_loaderClient.didReceiveServerRedirectForProvisionalLoadForFrame(this, frame, userData.get());
     632}
     633
     634void WebPageProxy::didFailProvisionalLoadForFrame(uint64_t frameID, CoreIPC::ArgumentDecoder* arguments)
     635{
     636    RefPtr<APIObject> userData;
     637    WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
     638    if (!arguments->decode(messageDecoder))
     639        return;
     640
     641    WebFrameProxy* frame = process()->webFrame(frameID);
     642
     643    m_loaderClient.didFailProvisionalLoadWithErrorForFrame(this, frame, userData.get());
     644}
     645
     646void WebPageProxy::didCommitLoadForFrame(uint64_t frameID, const String& mimeType, const PlatformCertificateInfo& certificateInfo, 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
    1065655    frame->setMIMEType(mimeType);
    1066656    frame->setCertificateInfo(WebCertificateInfo::create(certificateInfo));
    1067657    frame->didCommitLoad();
    1068     m_loaderClient.didCommitLoadForFrame(this, frame, userData);
    1069 }
    1070 
    1071 void WebPageProxy::didFinishDocumentLoadForFrame(WebFrameProxy* frame, APIObject* userData)
    1072 {
    1073     m_loaderClient.didFinishDocumentLoadForFrame(this, frame, userData);
    1074 }
    1075 
    1076 void WebPageProxy::didFinishLoadForFrame(WebFrameProxy* frame, APIObject* userData)
    1077 {
     658    m_loaderClient.didCommitLoadForFrame(this, frame, userData.get());
     659}
     660
     661void WebPageProxy::didFinishDocumentLoadForFrame(uint64_t frameID, CoreIPC::ArgumentDecoder* arguments)
     662{
     663    RefPtr<APIObject> userData;
     664    WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
     665    if (!arguments->decode(messageDecoder))
     666        return;
     667
     668    WebFrameProxy* frame = process()->webFrame(frameID);
     669
     670    m_loaderClient.didFinishDocumentLoadForFrame(this, frame, userData.get());
     671}
     672
     673void WebPageProxy::didFinishLoadForFrame(uint64_t frameID, CoreIPC::ArgumentDecoder* arguments)
     674{
     675    RefPtr<APIObject> userData;
     676    WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
     677    if (!arguments->decode(messageDecoder))
     678        return;
     679
     680    WebFrameProxy* frame = process()->webFrame(frameID);
     681
    1078682    frame->didFinishLoad();
    1079     m_loaderClient.didFinishLoadForFrame(this, frame, userData);
    1080 }
    1081 
    1082 void WebPageProxy::didFailLoadForFrame(WebFrameProxy* frame, APIObject* userData)
    1083 {
    1084     m_loaderClient.didFailLoadWithErrorForFrame(this, frame, userData);
    1085 }
    1086 
    1087 void WebPageProxy::didReceiveTitleForFrame(WebFrameProxy* frame, const String& title, APIObject* userData)
    1088 {
     683    m_loaderClient.didFinishLoadForFrame(this, frame, userData.get());
     684}
     685
     686void WebPageProxy::didFailLoadForFrame(uint64_t frameID, CoreIPC::ArgumentDecoder* arguments)
     687{
     688    RefPtr<APIObject> userData;
     689    WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
     690    if (!arguments->decode(messageDecoder))
     691        return;
     692
     693    WebFrameProxy* frame = process()->webFrame(frameID);
     694
     695    m_loaderClient.didFailLoadWithErrorForFrame(this, frame, userData.get());
     696}
     697
     698void WebPageProxy::didReceiveTitleForFrame(uint64_t frameID, const String& title, CoreIPC::ArgumentDecoder* arguments)
     699{
     700    RefPtr<APIObject> userData;
     701    WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
     702    if (!arguments->decode(messageDecoder))
     703        return;
     704
     705    WebFrameProxy* frame = process()->webFrame(frameID);
     706
    1089707    frame->didReceiveTitle(title);
    1090708
    … …  
    1093711        m_pageTitle = title;
    1094712
    1095     m_loaderClient.didReceiveTitleForFrame(this, title, frame, userData);
    1096 }
    1097 
    1098 void WebPageProxy::didFirstLayoutForFrame(WebFrameProxy* frame, APIObject* userData)
    1099 {
    1100     m_loaderClient.didFirstLayoutForFrame(this, frame, userData);
    1101 }
    1102 
    1103 void WebPageProxy::didFirstVisuallyNonEmptyLayoutForFrame(WebFrameProxy* frame, APIObject* userData)
    1104 {
    1105     m_loaderClient.didFirstVisuallyNonEmptyLayoutForFrame(this, frame, userData);
    1106 }
    1107 
    1108 void WebPageProxy::didRemoveFrameFromHierarchy(WebFrameProxy* frame, APIObject* userData)
    1109 {
    1110     m_loaderClient.didRemoveFrameFromHierarchy(this, frame, userData);
     713    m_loaderClient.didReceiveTitleForFrame(this, title, frame, userData.get());
     714}
     715
     716void WebPageProxy::didFirstLayoutForFrame(uint64_t frameID, CoreIPC::ArgumentDecoder* arguments)
     717{
     718    RefPtr<APIObject> userData;
     719    WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
     720    if (!arguments->decode(messageDecoder))
     721        return;
     722
     723    WebFrameProxy* frame = process()->webFrame(frameID);
     724
     725    m_loaderClient.didFirstLayoutForFrame(this, frame, userData.get());
     726}
     727
     728void WebPageProxy::didFirstVisuallyNonEmptyLayoutForFrame(uint64_t frameID, CoreIPC::ArgumentDecoder* arguments)
     729{
     730    RefPtr<APIObject> userData;
     731    WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
     732    if (!arguments->decode(messageDecoder))
     733        return;
     734
     735    WebFrameProxy* frame = process()->webFrame(frameID);
     736
     737    m_loaderClient.didFirstVisuallyNonEmptyLayoutForFrame(this, frame, userData.get());
     738}
     739
     740void WebPageProxy::didRemoveFrameFromHierarchy(uint64_t frameID, CoreIPC::ArgumentDecoder* arguments)
     741{
     742    RefPtr<APIObject> userData;
     743    WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
     744    if (!arguments->decode(messageDecoder))
     745        return;
     746
     747    WebFrameProxy* frame = process()->webFrame(frameID);
     748
     749    m_loaderClient.didRemoveFrameFromHierarchy(this, frame, userData.get());
    1111750}
    1112751
    1113752// PolicyClient
    1114753
    1115 void WebPageProxy::decidePolicyForNavigationAction(WebFrameProxy* frame, NavigationType navigationType, WebEvent::Modifiers modifiers, WebMouseEvent::Button mouseButton, const String& url, uint64_t listenerID)
    1116 {
     754void WebPageProxy::decidePolicyForNavigationAction(uint64_t frameID, uint32_t opaqueNavigationType, uint32_t opaqueModifiers, int32_t opaqueMouseButton, const String& url, uint64_t listenerID)
     755{
     756    WebFrameProxy* frame = process()->webFrame(frameID);
     757    NavigationType navigationType = static_cast<NavigationType>(opaqueNavigationType);
     758    WebEvent::Modifiers modifiers = static_cast<WebEvent::Modifiers>(opaqueModifiers);
     759    WebMouseEvent::Button mouseButton = static_cast<WebMouseEvent::Button>(opaqueMouseButton);
     760   
    1117761    RefPtr<WebFramePolicyListenerProxy> listener = frame->setUpPolicyListenerProxy(listenerID);
    1118762    if (!m_policyClient.decidePolicyForNavigationAction(this, navigationType, modifiers, mouseButton, url, frame, listener.get()))
    … …  
    1120764}
    1121765
    1122 void WebPageProxy::decidePolicyForNewWindowAction(WebFrameProxy* frame, NavigationType navigationType, WebEvent::Modifiers modifiers, WebMouseEvent::Button mouseButton, const String& url, uint64_t listenerID)
    1123 {
     766void WebPageProxy::decidePolicyForNewWindowAction(uint64_t frameID, uint32_t opaqueNavigationType, uint32_t opaqueModifiers, int32_t opaqueMouseButton, const String& url, uint64_t listenerID)
     767{
     768    WebFrameProxy* frame = process()->webFrame(frameID);
     769    NavigationType navigationType = static_cast<NavigationType>(opaqueNavigationType);
     770    WebEvent::Modifiers modifiers = static_cast<WebEvent::Modifiers>(opaqueModifiers);
     771    WebMouseEvent::Button mouseButton = static_cast<WebMouseEvent::Button>(opaqueMouseButton);
     772
    1124773    RefPtr<WebFramePolicyListenerProxy> listener = frame->setUpPolicyListenerProxy(listenerID);
    1125774    if (!m_policyClient.decidePolicyForNewWindowAction(this, navigationType, modifiers, mouseButton, url, frame, listener.get()))
    … …  
    1127776}
    1128777
    1129 void WebPageProxy::decidePolicyForMIMEType(WebFrameProxy* frame, const String& MIMEType, const String& url, uint64_t listenerID)
    1130 {
     778void WebPageProxy::decidePolicyForMIMEType(uint64_t frameID, const String& MIMEType, const String& url, uint64_t listenerID)
     779{
     780    WebFrameProxy* frame = process()->webFrame(frameID);
    1131781    RefPtr<WebFramePolicyListenerProxy> listener = frame->setUpPolicyListenerProxy(listenerID);
    1132782    if (!m_policyClient.decidePolicyForMIMEType(this, MIMEType, url, frame, listener.get()))
    … …  
    1136786// FormClient
    1137787
    1138 void WebPageProxy::willSubmitForm(WebFrameProxy* frame, WebFrameProxy* sourceFrame, Vector<std::pair<String, String> >& textFieldValues, APIObject* userData, uint64_t listenerID)
    1139 {
     788void WebPageProxy::willSubmitForm(uint64_t frameID, uint64_t sourceFrameID, const StringPairVector& textFieldValues, uint64_t listenerID, CoreIPC::ArgumentDecoder* arguments)
     789{
     790    RefPtr<APIObject> userData;
     791    WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
     792    if (!arguments->decode(messageDecoder))
     793        return;
     794
     795    WebFrameProxy* frame = process()->webFrame(frameID);
     796    WebFrameProxy* sourceFrame = process()->webFrame(sourceFrameID);
     797
    1140798    RefPtr<WebFormSubmissionListenerProxy> listener = frame->setUpFormSubmissionListenerProxy(listenerID);
    1141     if (!m_formClient.willSubmitForm(this, frame, sourceFrame, textFieldValues, userData, listener.get()))
     799    if (!m_formClient.willSubmitForm(this, frame, sourceFrame, textFieldValues.stringPairVector(), userData.get(), listener.get()))
    1142800        listener->continueSubmission();
    1143801}
    … …  
    1145803// UIClient
    1146804
    1147 PassRefPtr<WebPageProxy> WebPageProxy::createNewPage()
    1148 {
    1149     return m_uiClient.createNewPage(this);
     805void WebPageProxy::createNewPage(uint64_t& newPageID, WebPageCreationParameters& newPageParameters)
     806{
     807    RefPtr<WebPageProxy> newPage = m_uiClient.createNewPage(this);
     808    if (newPage) {
     809        // FIXME: Pass the real size.
     810        newPageID = newPage->pageID();
     811        newPageParameters = newPage->creationParameters(IntSize(100, 100));
     812    } else
     813        newPageID = 0;
    1150814}
    1151815   
    … …  
    1160824}
    1161825
    1162 void WebPageProxy::runJavaScriptAlert(WebFrameProxy* frame, const String& message)
    1163 {
    1164     m_uiClient.runJavaScriptAlert(this, message, frame);
    1165 }
    1166 
    1167 bool WebPageProxy::runJavaScriptConfirm(WebFrameProxy* frame, const String& message)
    1168 {
    1169     return m_uiClient.runJavaScriptConfirm(this, message, frame);
    1170 }
    1171 
    1172 String WebPageProxy::runJavaScriptPrompt(WebFrameProxy* frame, const String& message, const String& defaultValue)
    1173 {
    1174     return m_uiClient.runJavaScriptPrompt(this, message, defaultValue, frame);
     826void WebPageProxy::runJavaScriptAlert(uint64_t frameID, const String& message)
     827{
     828    m_uiClient.runJavaScriptAlert(this, message, process()->webFrame(frameID));
     829}
     830
     831void WebPageProxy::runJavaScriptConfirm(uint64_t frameID, const String& message, bool& result)
     832{
     833    result = m_uiClient.runJavaScriptConfirm(this, message, process()->webFrame(frameID));
     834}
     835
     836void WebPageProxy::runJavaScriptPrompt(uint64_t frameID, const String& message, const String& defaultValue, String& result)
     837{
     838    result = m_uiClient.runJavaScriptPrompt(this, message, defaultValue, process()->webFrame(frameID));
    1175839}
    1176840
    … …  
    1180844}
    1181845
    1182 void WebPageProxy::mouseDidMoveOverElement(WebEvent::Modifiers modifiers, APIObject* userData)
    1183 {
    1184     m_uiClient.mouseDidMoveOverElement(this, modifiers, userData);
    1185 }
    1186 
    1187 void WebPageProxy::contentsSizeChanged(WebFrameProxy* frame, const WebCore::IntSize& size)
    1188 {
    1189     m_uiClient.contentsSizeChanged(this, size, frame);
     846void WebPageProxy::mouseDidMoveOverElement(uint32_t opaqueModifiers, CoreIPC::ArgumentDecoder* arguments)
     847{
     848
     849    RefPtr<APIObject> userData;
     850    WebContextUserMessageDecoder messageDecoder(userData, pageNamespace()->context());
     851    if (!arguments->decode(messageDecoder))
     852        return;
     853
     854    WebEvent::Modifiers modifiers = static_cast<WebEvent::Modifiers>(opaqueModifiers);
     855
     856    m_uiClient.mouseDidMoveOverElement(this, modifiers, userData.get());
     857}
     858
     859void WebPageProxy::contentsSizeChanged(uint64_t frameID, const WebCore::IntSize& size)
     860{
     861    m_uiClient.contentsSizeChanged(this, size, process()->webFrame(frameID));
    1190862}
    1191863
    1192864// BackForwardList
    1193865
    1194 void WebPageProxy::addItemToBackForwardList(WebBackForwardListItem* item)
    1195 {
    1196     m_backForwardList->addItem(item);
    1197 }
    1198 
    1199 void WebPageProxy::goToItemInBackForwardList(WebBackForwardListItem* item)
    1200 {
    1201     m_backForwardList->goToItem(item);
     866void WebPageProxy::backForwardAddItem(uint64_t itemID)
     867{
     868    m_backForwardList->addItem(process()->webBackForwardItem(itemID));
     869}
     870
     871void WebPageProxy::backForwardGoToItem(uint64_t itemID)
     872{
     873    m_backForwardList->goToItem(process()->webBackForwardItem(itemID));
     874}
     875
     876void WebPageProxy::backForwardBackItem(uint64_t& itemID)
     877{
     878    WebBackForwardListItem* backItem = m_backForwardList->backItem();
     879    itemID = backItem ? backItem->itemID() : 0;
     880}
     881
     882void WebPageProxy::backForwardCurrentItem(uint64_t& itemID)
     883{
     884    WebBackForwardListItem* currentItem = m_backForwardList->currentItem();
     885    itemID = currentItem ? currentItem->itemID() : 0;
     886}
     887
     888void WebPageProxy::backForwardForwardItem(uint64_t& itemID)
     889{
     890    WebBackForwardListItem* forwardItem = m_backForwardList->forwardItem();
     891    itemID = forwardItem ? forwardItem->itemID() : 0;
     892}
     893
     894void WebPageProxy::backForwardItemAtIndex(int32_t index, uint64_t& itemID)
     895{
     896    WebBackForwardListItem* item = m_backForwardList->itemAtIndex(index);
     897    itemID = item ? item->itemID() : 0;
     898}
     899
     900void WebPageProxy::backForwardBackListCount(int32_t& count)
     901{
     902    count = m_backForwardList->backListCount();
     903}
     904
     905void WebPageProxy::backForwardForwardListCount(int32_t& count)
     906{
     907    count = m_backForwardList->forwardListCount();
    1202908}
    1203909
    1204910// Undo management
    1205911
    1206 void WebPageProxy::registerEditCommandForUndo(uint64_t commandID, EditAction editAction)
    1207 {
    1208     registerEditCommandForUndo(WebEditCommandProxy::create(commandID, editAction, this));
     912void WebPageProxy::registerEditCommandForUndo(uint64_t commandID, uint32_t editAction)
     913{
     914    registerEditCommand(WebEditCommandProxy::create(commandID, static_cast<EditAction>(editAction), this), Undo);
    1209915}
    1210916
    … …  
    1214920}
    1215921
    1216 void WebPageProxy::registerEditCommandForUndo(PassRefPtr<WebEditCommandProxy> commandProxy)
    1217 {
    1218     m_pageClient->registerEditCommand(commandProxy, PageClient::Undo);
    1219 }
    1220 
    1221 void WebPageProxy::registerEditCommandForRedo(PassRefPtr<WebEditCommandProxy> commandProxy)
    1222 {
    1223     m_pageClient->registerEditCommand(commandProxy, PageClient::Redo);
     922void WebPageProxy::registerEditCommand(PassRefPtr<WebEditCommandProxy> commandProxy, UndoOrRedo undoOrRedo)
     923{
     924    m_pageClient->registerEditCommand(commandProxy, undoOrRedo);
    1224925}
    1225926
    … …  
    1257958}
    1258959
    1259 void WebPageProxy::didReceiveEvent(WebEvent::Type type, bool handled)
    1260 {
     960void WebPageProxy::didValidateMenuItem(const String& commandName, bool isEnabled, int32_t state)
     961{
     962    m_pageClient->setEditCommandState(commandName, isEnabled, state);
     963}
     964
     965void WebPageProxy::didReceiveEvent(uint32_t opaqueType, bool handled)
     966{
     967    WebEvent::Type type = static_cast<WebEvent::Type>(opaqueType);
     968
    1261969    switch (type) {
    1262970        case WebEvent::MouseMove:
    … …  
    13201028}
    13211029
     1030
    13221031#if USE(ACCELERATED_COMPOSITING)
    1323 void WebPageProxy::didChangeAcceleratedCompositing(bool compositing)
     1032void WebPageProxy::didChangeAcceleratedCompositing(bool compositing, DrawingAreaBase::DrawingAreaInfo& drawingAreaInfo)
    13241033{
    13251034    if (compositing)
    … …  
    13271036    else
    13281037        didLeaveAcceleratedCompositing();
     1038
     1039    drawingAreaInfo = drawingArea()->info();
    13291040}
    13301041#endif

  • trunk/WebKit2/UIProcess/WebPageProxy.h

    r69325 r69329  
    6868class PageClient;
    6969class PlatformCertificateInfo;
     70class StringPairVector;
    7071class WebBackForwardList;
    7172class WebBackForwardListItem;
    … …  
    195196#endif
    196197
     198    enum UndoOrRedo { Undo, Redo };
    197199    void addEditCommand(WebEditCommandProxy*);
    198200    void removeEditCommand(WebEditCommandProxy*);
    199     void registerEditCommandForUndo(PassRefPtr<WebEditCommandProxy>);
    200     void registerEditCommandForRedo(PassRefPtr<WebEditCommandProxy>);
     201    void registerEditCommand(PassRefPtr<WebEditCommandProxy>, UndoOrRedo);
    201202
    202203    WebProcessProxy* process() const;
    … …  
    217218    virtual Type type() const { return APIType; }
    218219
     220    // Implemented in generated WebPageProxyMessageReceiver.cpp
     221    void didReceiveWebPageProxyMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*);
     222    CoreIPC::SyncReplyMode didReceiveSyncWebPageProxyMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*, CoreIPC::ArgumentEncoder*);
     223
    219224    void didCreateMainFrame(uint64_t frameID);
    220225    void didCreateSubFrame(uint64_t frameID);
    221226
    222     void didStartProvisionalLoadForFrame(WebFrameProxy*, const String&, APIObject*);
    223     void didReceiveServerRedirectForProvisionalLoadForFrame(WebFrameProxy*, const String&, APIObject*);
    224     void didFailProvisionalLoadForFrame(WebFrameProxy*, APIObject*);
    225     void didCommitLoadForFrame(WebFrameProxy*, const String& mimeType, const PlatformCertificateInfo&, APIObject*);
    226     void didFinishDocumentLoadForFrame(WebFrameProxy*, APIObject*);
    227     void didFinishLoadForFrame(WebFrameProxy*, APIObject*);
    228     void didFailLoadForFrame(WebFrameProxy*, APIObject*);
    229     void didReceiveTitleForFrame(WebFrameProxy*, const String&, APIObject*);
    230     void didFirstLayoutForFrame(WebFrameProxy*, APIObject*);
    231     void didFirstVisuallyNonEmptyLayoutForFrame(WebFrameProxy*, APIObject*);
    232     void didRemoveFrameFromHierarchy(WebFrameProxy*, APIObject*);
     227    void didStartProvisionalLoadForFrame(uint64_t frameID, const String&, CoreIPC::ArgumentDecoder*);
     228    void didReceiveServerRedirectForProvisionalLoadForFrame(uint64_t frameID, const String&, CoreIPC::ArgumentDecoder*);
     229    void didFailProvisionalLoadForFrame(uint64_t frameID, CoreIPC::ArgumentDecoder*);
     230    void didCommitLoadForFrame(uint64_t frameID, const String& mimeType, const PlatformCertificateInfo&, CoreIPC::ArgumentDecoder*);
     231    void didFinishDocumentLoadForFrame(uint64_t frameID, CoreIPC::ArgumentDecoder*);
     232    void didFinishLoadForFrame(uint64_t frameID, CoreIPC::ArgumentDecoder*);
     233    void didFailLoadForFrame(uint64_t frameID, CoreIPC::ArgumentDecoder*);
     234    void didReceiveTitleForFrame(uint64_t frameID, const String&, CoreIPC::ArgumentDecoder*);
     235    void didFirstLayoutForFrame(uint64_t frameID, CoreIPC::ArgumentDecoder*);
     236    void didFirstVisuallyNonEmptyLayoutForFrame(uint64_t frameID, CoreIPC::ArgumentDecoder*);
     237    void didRemoveFrameFromHierarchy(uint64_t frameID, CoreIPC::ArgumentDecoder*);
    233238    void didStartProgress();
    234239    void didChangeProgress(double);
    235240    void didFinishProgress();
    236241   
    237     void decidePolicyForNavigationAction(WebFrameProxy*, WebCore::NavigationType, WebEvent::Modifiers, WebMouseEvent::Button, const String& url, uint64_t listenerID);
    238     void decidePolicyForNewWindowAction(WebFrameProxy*, WebCore::NavigationType, WebEvent::Modifiers, WebMouseEvent::Button, const String& url, uint64_t listenerID);
    239     void decidePolicyForMIMEType(WebFrameProxy*, const String& MIMEType, const String& url, uint64_t listenerID);
    240 
    241     void willSubmitForm(WebFrameProxy* frame, WebFrameProxy* frameSource, Vector<std::pair<String, String> >& textFieldValues, APIObject* userData, uint64_t listenerID);
    242 
    243     PassRefPtr<WebPageProxy> createNewPage();
     242    void decidePolicyForNavigationAction(uint64_t frameID, uint32_t navigationType, uint32_t modifiers, int32_t mouseButton, const String& url, uint64_t listenerID);
     243    void decidePolicyForNewWindowAction(uint64_t frameID, uint32_t navigationType, uint32_t modifiers, int32_t mouseButton, const String& url, uint64_t listenerID);
     244    void decidePolicyForMIMEType(uint64_t frameID, const String& MIMEType, const String& url, uint64_t listenerID);
     245
     246    void willSubmitForm(uint64_t frameID, uint64_t sourceFrameID, const StringPairVector& textFieldValues, uint64_t listenerID, CoreIPC::ArgumentDecoder*);
     247
     248    void createNewPage(uint64_t& newPageID, WebPageCreationParameters&);
    244249    void showPage();
    245250    void closePage();
    246     void runJavaScriptAlert(WebFrameProxy*, const String&);
    247     bool runJavaScriptConfirm(WebFrameProxy* frame, const String&);
    248     String runJavaScriptPrompt(WebFrameProxy* frame, const String&, const String&);
     251    void runJavaScriptAlert(uint64_t frameID, const String&);
     252    void runJavaScriptConfirm(uint64_t frameID, const String&, bool& result);
     253    void runJavaScriptPrompt(uint64_t frameID, const String&, const String&, String& result);
    249254    void setStatusText(const String&);
    250     void mouseDidMoveOverElement(WebEvent::Modifiers, APIObject*);
    251     void contentsSizeChanged(WebFrameProxy*, const WebCore::IntSize&);
     255    void mouseDidMoveOverElement(uint32_t modifiers, CoreIPC::ArgumentDecoder*);
     256    void contentsSizeChanged(uint64_t frameID, const WebCore::IntSize&);
    252257
    253258    // Back/Forward list management
    254     void addItemToBackForwardList(WebBackForwardListItem*);
    255     void goToItemInBackForwardList(WebBackForwardListItem*);
     259    void backForwardAddItem(uint64_t itemID);
     260    void backForwardGoToItem(uint64_t itemID);
     261    void backForwardBackItem(uint64_t& itemID);
     262    void backForwardCurrentItem(uint64_t& itemID);
     263    void backForwardForwardItem(uint64_t& itemID);
     264    void backForwardItemAtIndex(int32_t index, uint64_t& itemID);
     265    void backForwardBackListCount(int32_t& count);
     266    void backForwardForwardListCount(int32_t& count);
    256267
    257268    // Undo management
    258     void registerEditCommandForUndo(uint64_t commandID, WebCore::EditAction);
     269    void registerEditCommandForUndo(uint64_t commandID, uint32_t editAction);
    259270    void clearAllEditCommands();
    260271
    … …  
    262273    void setToolTip(const String&);
    263274    void setCursor(const WebCore::Cursor&);
    264 
    265     void didReceiveEvent(WebEvent::Type, bool handled);
     275    void didValidateMenuItem(const String& commandName, bool isEnabled, int32_t state);
     276
     277    void didReceiveEvent(uint32_t opaqueType, bool handled);
    266278
    267279    void didRunJavaScriptInMainFrame(const String&, uint64_t);
    … …  
    272284
    273285#if USE(ACCELERATED_COMPOSITING)
    274     void didChangeAcceleratedCompositing(bool compositing);
     286    void didChangeAcceleratedCompositing(bool compositing, DrawingAreaBase::DrawingAreaInfo&);
    275287#endif   
    276288

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

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

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

    r69229 r69329  
    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

    r69324 r69329  
    143143WEBKIT2_GENERATED_HEADERS = \
    144144    $$OUTPUT_DIR/WebKit2/generated/WebPageMessages.h \
     145    $$OUTPUT_DIR/WebKit2/generated/WebPageProxyMessages.h \
    145146    $$OUTPUT_DIR/WebKit2/generated/WebProcessMessages.h
    146147
    147148WEBKIT2_GENERATED_SOURCES = \
    148149    $$OUTPUT_DIR/WebKit2/generated/WebPageMessageReceiver.cpp \
     150    $$OUTPUT_DIR/WebKit2/generated/WebPageProxyMessageReceiver.cpp \
    149151    $$OUTPUT_DIR/WebKit2/generated/WebProcessMessageReceiver.cpp
    150152
    … …  
    179181    Shared/CoreIPCSupport/DrawingAreaMessageKinds.h \
    180182    Shared/CoreIPCSupport/DrawingAreaProxyMessageKinds.h \
    181     Shared/CoreIPCSupport/WebPageProxyMessageKinds.h \
    182183    Shared/CacheModel.h \
    183184    Shared/DrawingAreaBase.h \
    … …  
    188189    Shared/NativeWebKeyboardEvent.h \
    189190    Shared/NotImplemented.h \
     191    Shared/StringPairVector.h \
    190192    Shared/qt/MappedMemory.h \
    191193    Shared/qt/PlatformCertificateInfo.h \

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

    r69323 r69329  
    192192                BC111B5D112F629800337BAB /* WebEventFactory.h in Headers */ = {isa = PBXBuildFile; fileRef = BC111B5B112F629800337BAB /* WebEventFactory.h */; };
    193193                BC111B5E112F629800337BAB /* WebEventFactory.mm in Sources */ = {isa = PBXBuildFile; fileRef = BC111B5C112F629800337BAB /* WebEventFactory.mm */; };
    194                 BC111B64112F638300337BAB /* WebPageProxyMessageKinds.h in Headers */ = {isa = PBXBuildFile; fileRef = BC111B61112F638300337BAB /* WebPageProxyMessageKinds.h */; };
    195                 BC111B65112F638300337BAB /* WebProcessMessageKinds.h in Headers */ = {isa = PBXBuildFile; fileRef = BC111B62112F638300337BAB /* WebProcessMessageKinds.h */; };
    196194                BC131BC911726C2800B69727 /* CoreIPCMessageKinds.h in Headers */ = {isa = PBXBuildFile; fileRef = BC131BC811726C2800B69727 /* CoreIPCMessageKinds.h */; };
    197195                BC14DF77120B5B7900826C0C /* InjectedBundleScriptWorld.h in Headers */ = {isa = PBXBuildFile; fileRef = BC14DF75120B5B7900826C0C /* InjectedBundleScriptWorld.h */; };
    … …  
    354352                BCBCB0CB1215E32100DE59CA /* ImmutableDictionary.h in Headers */ = {isa = PBXBuildFile; fileRef = BCBCB0CA1215E32100DE59CA /* ImmutableDictionary.h */; };
    355353                BCBCB0CD1215E33A00DE59CA /* ImmutableDictionary.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BCBCB0CC1215E33A00DE59CA /* ImmutableDictionary.cpp */; };
     354                BCBD3914125BB1A800D2C29F /* WebPageProxyMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BCBD3912125BB1A800D2C29F /* WebPageProxyMessageReceiver.cpp */; };
     355                BCBD3915125BB1A800D2C29F /* WebPageProxyMessages.h in Headers */ = {isa = PBXBuildFile; fileRef = BCBD3913125BB1A800D2C29F /* WebPageProxyMessages.h */; };
     356                BCBD3C3B125BFA7A00D2C29F /* StringPairVector.h in Headers */ = {isa = PBXBuildFile; fileRef = BCBD3C3A125BFA7A00D2C29F /* StringPairVector.h */; };
    356357                BCC56F791159957D001CCAF9 /* MachPort.h in Headers */ = {isa = PBXBuildFile; fileRef = BCC56F771159957D001CCAF9 /* MachPort.h */; };
    357358                BCC5715B115ADAEF001CCAF9 /* WebSystemInterface.h in Headers */ = {isa = PBXBuildFile; fileRef = BCC57159115ADAEF001CCAF9 /* WebSystemInterface.h */; };
    … …  
    646647                BC111B5B112F629800337BAB /* WebEventFactory.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebEventFactory.h; sourceTree = "<group>"; };
    647648                BC111B5C112F629800337BAB /* WebEventFactory.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WebEventFactory.mm; sourceTree = "<group>"; };
    648                 BC111B61112F638300337BAB /* WebPageProxyMessageKinds.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebPageProxyMessageKinds.h; sourceTree = "<group>"; };
    649                 BC111B62112F638300337BAB /* WebProcessMessageKinds.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebProcessMessageKinds.h; sourceTree = "<group>"; };
    650649                BC131BC811726C2800B69727 /* CoreIPCMessageKinds.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CoreIPCMessageKinds.h; sourceTree = "<group>"; };
    651650                BC14DF75120B5B7900826C0C /* InjectedBundleScriptWorld.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InjectedBundleScriptWorld.h; sourceTree = "<group>"; };
    … …  
    808807                BCBCB0CA1215E32100DE59CA /* ImmutableDictionary.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ImmutableDictionary.h; sourceTree = "<group>"; };
    809808                BCBCB0CC1215E33A00DE59CA /* ImmutableDictionary.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ImmutableDictionary.cpp; sourceTree = "<group>"; };
     809                BCBD38FA125BAB9A00D2C29F /* WebPageProxy.messages.in */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = WebPageProxy.messages.in; sourceTree = "<group>"; };
     810                BCBD3912125BB1A800D2C29F /* WebPageProxyMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebPageProxyMessageReceiver.cpp; sourceTree = "<group>"; };
     811                BCBD3913125BB1A800D2C29F /* WebPageProxyMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebPageProxyMessages.h; sourceTree = "<group>"; };
     812                BCBD3C3A125BFA7A00D2C29F /* StringPairVector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StringPairVector.h; sourceTree = "<group>"; };
    810813                BCC56F771159957D001CCAF9 /* MachPort.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MachPort.h; sourceTree = "<group>"; };
    811814                BCC57159115ADAEF001CCAF9 /* WebSystemInterface.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebSystemInterface.h; sourceTree = "<group>"; };
    … …  
    11351138                                BC1DD7B1114DC396005ADAF3 /* WebCoreArgumentCoders.h */,
    11361139                                BCF50726124329AA005955AE /* WebCertificateInfo.h */,
     1140                                BCBD3C3A125BFA7A00D2C29F /* StringPairVector.h */,
    11371141                                51578B821209ECEF00A37C4A /* WebData.h */,
    11381142                                516A4A5B120A2CCD00C05B7F /* WebError.h */,
    … …  
    13351339                                BC111B0B112F5E4F00337BAB /* WebPageProxy.cpp */,
    13361340                                BC032DCB10F4389F0058C15A /* WebPageProxy.h */,
     1341                                BCBD38FA125BAB9A00D2C29F /* WebPageProxy.messages.in */,
    13371342                                BCB9F8AD1124E07700A137E0 /* WebPolicyClient.cpp */,
    13381343                                BCB9F8AE1124E07700A137E0 /* WebPolicyClient.h */,
    … …  
    14651470                                BCB28CBF120233D9007D99BC /* InjectedBundleMessageKinds.h */,
    14661471                                BCCB75C51203A1CE00222D1B /* WebContextMessageKinds.h */,
    1467                                 BC111B61112F638300337BAB /* WebPageProxyMessageKinds.h */,
    1468                                 BC111B62112F638300337BAB /* WebProcessMessageKinds.h */,
    14691472                                BCB7346D11CEE3FF00EC5002 /* WebProcessProxyMessageKinds.h */,
    14701473                        );
    … …  
    17091712                                C0CE729E1247E71D00BC0EC4 /* WebPageMessageReceiver.cpp */,
    17101713                                C0CE729F1247E71D00BC0EC4 /* WebPageMessages.h */,
     1714                                BCBD3912125BB1A800D2C29F /* WebPageProxyMessageReceiver.cpp */,
     1715                                BCBD3913125BB1A800D2C29F /* WebPageProxyMessages.h */,
    17111716                                1A043F6712514D8B00FFBFB5 /* WebProcessConnectionMessageReceiver.cpp */,
    17121717                                1A043F6812514D8B00FFBFB5 /* WebProcessConnectionMessages.h */,
    … …  
    18141819                                BCEE98C7113314D7006BCC24 /* WebPageNamespace.h in Headers */,
    18151820                                BC032DD110F4389F0058C15A /* WebPageProxy.h in Headers */,
    1816                                 BC111B64112F638300337BAB /* WebPageProxyMessageKinds.h in Headers */,
    18171821                                1A3E736111CC2659007BD539 /* WebPlatformStrategies.h in Headers */,
    18181822                                BCB9F8B01124E07700A137E0 /* WebPolicyClient.h in Headers */,
    … …  
    18221826                                1A6FA02011E1528700DB1371 /* WebProcessMain.h in Headers */,
    18231827                                BC032DD310F4389F0058C15A /* WebProcessManager.h in Headers */,
    1824                                 BC111B65112F638300337BAB /* WebProcessMessageKinds.h in Headers */,
    18251828                                BC032DD510F4389F0058C15A /* WebProcessProxy.h in Headers */,
    18261829                                BCB7346E11CEE3FF00EC5002 /* WebProcessProxyMessageKinds.h in Headers */,
    … …  
    19461949                                BC306824125A6B9400E71278 /* WebProcessCreationParameters.h in Headers */,
    19471950                                51A7F2F3125BF820008AEB1D /* Logging.h in Headers */,
     1951                                BCBD3915125BB1A800D2C29F /* WebPageProxyMessages.h in Headers */,
     1952                                BCBD3C3B125BFA7A00D2C29F /* StringPairVector.h in Headers */,
    19481953                        );
    19491954                        runOnlyForDeploymentPostprocessing = 0;
    … …  
    22442249                                BC306825125A6B9400E71278 /* WebProcessCreationParameters.cpp in Sources */,
    22452250                                51A7F2F5125BF8D4008AEB1D /* Logging.cpp in Sources */,
     2251                                BCBD3914125BB1A800D2C29F /* WebPageProxyMessageReceiver.cpp in Sources */,
    22462252                        );
    22472253                        runOnlyForDeploymentPostprocessing = 0;

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

    r69229 r69329  
    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

    r69229 r69329  
    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

    r69229 r69329  
    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

    r69229 r69329  
    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

    r69229 r69329  
    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

    r69323 r69329  
    449449                                >
    450450                        </File>
     451                        <File
     452                                RelativePath="..\Shared\StringPairVector.h"
     453                                >
     454                        </File>
     455                        <File
     456                                RelativePath="..\Shared\UserMessageCoders.h"
     457                                >                       
    451458                        <File
    452459                                RelativePath="..\Shared\UserMessageCoders.h"
    … …  
    768775                                        >
    769776                                </File>
    770                                 <File
    771                                         RelativePath="..\Shared\CoreIPCSupport\WebProcessProxyMessageKinds.h"
    772                                         >
    773                                 </File>
    774777                        </Filter>
    775778                        <Filter
    … …  
    15131516                                >
    15141517                        </File>
     1518                        <File
     1519                                RelativePath="..\UIProcess\WebPageProxy.messages.in"
     1520                                >
     1521                        </File>
    15151522                        <File
    15161523                                RelativePath="..\UIProcess\WebPolicyClient.cpp"
    … …  
    20362043                                RelativePath="$(WebKitOutputDir)\obj\$(ProjectName)\DerivedSources\WebPageMessages.h"
    20372044                                >
    2038                         </File>
     2045                        </File>
     2046                                RelativePath="$(WebKitOutputDir)\obj\$(ProjectName)\DerivedSources\WebPageProxyMessageReceiver.cpp"
     2047                                >
     2048                        </File>
     2049                        <File
     2050                                RelativePath="$(WebKitOutputDir)\obj\$(ProjectName)\DerivedSources\WebPageProxyMessages.h"
     2051                                >
     2052                        </File>
    20392053                        <File
    20402054                                RelativePath="$(WebKitOutputDir)\obj\$(ProjectName)\DerivedSources\WebProcessMessageReceiver.cpp"
Note: See TracChangeset for help on using the changeset viewer.