Attachment #186287 for bug #108785

View Details Raw Unified Return to Bug 108785



2013-02-03  Sam Weinig  <sam@webkit.org>

        Make WebPageProxy and sub-objects MessageReceivers
        https://bugs.webkit.org/show_bug.cgi?id=108785

        Reviewed by NOBODY (OOPS!).

        * UIProcess/CoordinatedGraphics/CoordinatedLayerTreeHostProxy.cpp:
        (WebKit::CoordinatedLayerTreeHostProxy::CoordinatedLayerTreeHostProxy):
        (WebKit::CoordinatedLayerTreeHostProxy::~CoordinatedLayerTreeHostProxy):
        * UIProcess/CoordinatedGraphics/CoordinatedLayerTreeHostProxy.h:
        (CoordinatedLayerTreeHostProxy):
        * UIProcess/CoordinatedGraphics/CoordinatedLayerTreeHostProxy.messages.in:
        * UIProcess/DrawingAreaProxy.cpp:
        (WebKit::DrawingAreaProxy::DrawingAreaProxy):
        (WebKit::DrawingAreaProxy::~DrawingAreaProxy):
        (WebKit::DrawingAreaProxy::contentsRect):
        * UIProcess/DrawingAreaProxy.h:
        (WebKit::DrawingAreaProxy::setVisibleContentsRect):
        * UIProcess/DrawingAreaProxy.messages.in:
        * UIProcess/DrawingAreaProxyImpl.cpp:
        (WebKit::DrawingAreaProxyImpl::setVisibleContentsRect):
        * UIProcess/DrawingAreaProxyImpl.h:
        * UIProcess/WebFullScreenManagerProxy.cpp:
        (WebKit::WebFullScreenManagerProxy::WebFullScreenManagerProxy):
        * UIProcess/WebFullScreenManagerProxy.h:
        (WebFullScreenManagerProxy):
        * UIProcess/WebFullScreenManagerProxy.messages.in:
        * UIProcess/WebInspectorProxy.cpp:
        (WebKit::WebInspectorProxy::WebInspectorProxy):
        (WebKit::WebInspectorProxy::invalidate):
        * UIProcess/WebInspectorProxy.h:
        * UIProcess/WebInspectorProxy.messages.in:
        * UIProcess/WebPageProxy.cpp:
        (WebKit::WebPageProxy::WebPageProxy):
        (WebKit::WebPageProxy::reattachToWebProcess):
        (WebKit::WebPageProxy::close):
        (WebKit::WebPageProxy::inspector):
        (WebKit::WebPageProxy::fullScreenManager):
        (WebKit::WebPageProxy::processDidCrash):
        * UIProcess/WebPageProxy.h:
        * UIProcess/WebPageProxy.messages.in:
        * UIProcess/WebProcessProxy.cpp:
        (WebKit::WebProcessProxy::didReceiveMessage):
        (WebKit::WebProcessProxy::didReceiveSyncMessage):
        * UIProcess/mac/WebFullScreenManagerProxyMac.mm:
        (WebKit::WebFullScreenManagerProxy::invalidate):

2013-02-03  Joanmarie Diggs  <jdiggs@igalia.com>

        [GTK] Make distcheck fails



#include "config.h"
#include "DrawingAreaProxy.h"

#include "DrawingAreaProxyMessages.h"
#include "WebPageProxy.h"
#include "WebProcessProxy.h"

#if USE(COORDINATED_GRAPHICS)
#include "CoordinatedLayerTreeHostProxy.h"

    , m_webPageProxy(webPageProxy)
    , m_size(webPageProxy->viewSize())
{
    m_webPageProxy->process()->addMessageReceiver(Messages::DrawingAreaProxy::messageReceiverName(), webPageProxy->pageID(), this);
}

DrawingAreaProxy::~DrawingAreaProxy()
{
    m_webPageProxy->process()->removeMessageReceiver(Messages::DrawingAreaProxy::messageReceiverName(), m_webPageProxy->pageID());
}

void DrawingAreaProxy::setSize(const IntSize& size, const IntSize& scrollOffset)

{
    return IntRect(IntPoint::zero(), m_webPageProxy->viewSize());
}

void DrawingAreaProxy::didReceiveCoordinatedLayerTreeHostProxyMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&)
{
}
#endif

} // namespace WebKit




#include "BackingStore.h"
#include "DrawingAreaInfo.h"
#include "MessageReceiver.h"
#include <WebCore/FloatPoint.h>
#include <WebCore/IntRect.h>
#include <WebCore/IntSize.h>
#include <stdint.h>
#include <wtf/Noncopyable.h>

namespace CoreIPC {
    class Connection;
    class MessageDecoder;
}

namespace WebCore {
    class TransformationMatrix;
}

namespace WebKit {

class LayerTreeContext;

class UpdateInfo;
class WebPageProxy;

class DrawingAreaProxy : public CoreIPC::MessageReceiver {
    WTF_MAKE_NONCOPYABLE(DrawingAreaProxy);

public:


    DrawingAreaType type() const { return m_type; }

    void didReceiveDrawingAreaProxyMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&);

    virtual void deviceScaleFactorDidChange() = 0;

    // FIXME: These should be pure virtual.

    virtual WebCore::IntRect contentsRect() const;
    CoordinatedLayerTreeHostProxy* coordinatedLayerTreeHostProxy() const { return m_coordinatedLayerTreeHostProxy.get(); }
    virtual void setVisibleContentsRect(const WebCore::FloatRect& /* visibleContentsRect */, const WebCore::FloatPoint& /* trajectoryVector */) { }
    virtual void didReceiveCoordinatedLayerTreeHostProxyMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&);

    WebPageProxy* page() { return m_webPageProxy; }
#endif

private:
    virtual void sizeDidChange() = 0;

    // CoreIPC::MessageReceiver
    virtual void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&) OVERRIDE;

    // CoreIPC message handlers.
    // FIXME: These should be pure virtual.
    virtual void update(uint64_t /* backingStoreStateID */, const UpdateInfo&) { }

Lines 20-26 Source/WebKit2/UIProcess/DrawingAreaProxy.messages.in_sec1
- Source/WebKit2/UIProcess/DrawingAreaProxy.messages.in -1 / +1 lines
20	# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE	20	# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
21	# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	21	# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
22		22
23	messages -> DrawingAreaProxy LegacyReceiver {	23	messages -> DrawingAreaProxy {
24	Update(uint64_t stateID, WebKit::UpdateInfo updateInfo)	24	Update(uint64_t stateID, WebKit::UpdateInfo updateInfo)
25	DidUpdateBackingStoreState(uint64_t backingStoreStateID, WebKit::UpdateInfo updateInfo, WebKit::LayerTreeContext context)	25	DidUpdateBackingStoreState(uint64_t backingStoreStateID, WebKit::UpdateInfo updateInfo, WebKit::LayerTreeContext context)
26	#if USE(ACCELERATED_COMPOSITING)	26	#if USE(ACCELERATED_COMPOSITING)



}

#if USE(COORDINATED_GRAPHICS)
void DrawingAreaProxyImpl::didReceiveCoordinatedLayerTreeHostProxyMessage(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder)
{
    if (m_coordinatedLayerTreeHostProxy)
        m_coordinatedLayerTreeHostProxy->didReceiveCoordinatedLayerTreeHostProxyMessage(connection, decoder);
}

void DrawingAreaProxyImpl::setVisibleContentsRect(const WebCore::FloatRect& visibleContentsRect, const WebCore::FloatPoint& trajectoryVector)
{
    if (m_coordinatedLayerTreeHostProxy)
        m_coordinatedLayerTreeHostProxy->setVisibleContentsRect(visibleContentsRect, trajectoryVector);
}

#endif

void DrawingAreaProxyImpl::exitAcceleratedCompositingMode()

Lines 84-90 private: Source/WebKit2/UIProcess/DrawingAreaProxyImpl.h_sec1
- Source/WebKit2/UIProcess/DrawingAreaProxyImpl.h -1 lines
84	void updateAcceleratedCompositingMode(const LayerTreeContext&);	84	void updateAcceleratedCompositingMode(const LayerTreeContext&);
85	#if USE(COORDINATED_GRAPHICS)	85	#if USE(COORDINATED_GRAPHICS)
86	virtual void setVisibleContentsRect(const WebCore::FloatRect& visibleContentsRect, const WebCore::FloatPoint& trajectory) OVERRIDE;	86	virtual void setVisibleContentsRect(const WebCore::FloatRect& visibleContentsRect, const WebCore::FloatPoint& trajectory) OVERRIDE;
87	void didReceiveCoordinatedLayerTreeHostProxyMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&);
88	#endif	87	#endif
89	#else	88	#else
90	bool isInAcceleratedCompositingMode() const { return false; }	89	bool isInAcceleratedCompositingMode() const { return false; }



    : m_page(page)
    , m_webView(0)
{
    m_page->process()->addMessageReceiver(Messages::WebFullScreenManagerProxy::messageReceiverName(), m_page->pageID(), this);
}

WebFullScreenManagerProxy::~WebFullScreenManagerProxy()

    m_webView = webView;
}

void WebFullScreenManagerProxy::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder)
{
    didReceiveWebFullScreenManagerProxyMessage(connection, decoder);
}

void WebFullScreenManagerProxy::didReceiveSyncMessage(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder, OwnPtr<CoreIPC::MessageEncoder>& replyEncoder)
{
    didReceiveSyncWebFullScreenManagerProxyMessage(connection, decoder, replyEncoder);
}

void WebFullScreenManagerProxy::willEnterFullScreen()
{
    m_page->process()->send(Messages::WebFullScreenManager::WillEnterFullScreen(), m_page->pageID());




#if ENABLE(FULLSCREEN_API)

#include "MessageReceiver.h"
#include <wtf/PassRefPtr.h>
#include <wtf/RefCounted.h>
#include <wtf/RefPtr.h>

namespace CoreIPC {
class ArgumentDecoder;
class Connection;
}

namespace WebCore {
class IntRect;
}

class WebPageProxy;
class LayerTreeContext;

class WebFullScreenManagerProxy : public RefCounted<WebFullScreenManagerProxy>, public CoreIPC::MessageReceiver {
public:
    static PassRefPtr<WebFullScreenManagerProxy> create(WebPageProxy*);
    virtual ~WebFullScreenManagerProxy();

    bool isFullScreen();
    void close();

    void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&);
    void didReceiveSyncMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&, OwnPtr<CoreIPC::MessageEncoder>&);

    void willEnterFullScreen();
    void didEnterFullScreen();
    void willExitFullScreen();

    void beganEnterFullScreen(const WebCore::IntRect& initialFrame, const WebCore::IntRect& finalFrame);
    void beganExitFullScreen(const WebCore::IntRect& initialFrame, const WebCore::IntRect& finalFrame);

    virtual void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&) OVERRIDE;
    virtual void didReceiveSyncMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&, OwnPtr<CoreIPC::MessageEncoder>&) OVERRIDE;

    WebPageProxy* m_page;
    PlatformWebView* m_webView;

    void didReceiveWebFullScreenManagerProxyMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&);
    void didReceiveSyncWebFullScreenManagerProxyMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&, OwnPtr<CoreIPC::MessageEncoder>&);
};

} // namespace WebKit

Lines 21-27 Source/WebKit2/UIProcess/WebFullScreenManagerProxy.messages.in_sec1
- Source/WebKit2/UIProcess/WebFullScreenManagerProxy.messages.in -1 / +1 lines
21	# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	21	# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
22		22
23	#if ENABLE(FULLSCREEN_API)	23	#if ENABLE(FULLSCREEN_API)
24	messages -> WebFullScreenManagerProxy LegacyReceiver {	24	messages -> WebFullScreenManagerProxy {
25	SupportsFullScreen(bool withKeyboard) -> (bool supportsFullScreen)	25	SupportsFullScreen(bool withKeyboard) -> (bool supportsFullScreen)
26	EnterFullScreen()	26	EnterFullScreen()
27	ExitFullScreen()	27	ExitFullScreen()

Lines 32-37 Source/WebKit2/UIProcess/WebInspectorProxy.cpp_sec1
- Source/WebKit2/UIProcess/WebInspectorProxy.cpp +4 lines
32	#include "WebFramePolicyListenerProxy.h"	32	#include "WebFramePolicyListenerProxy.h"
33	#include "WebFrameProxy.h"	33	#include "WebFrameProxy.h"
34	#include "WebInspectorMessages.h"	34	#include "WebInspectorMessages.h"
		35	#include "WebInspectorProxyMessages.h"
35	#include "WebPageCreationParameters.h"	36	#include "WebPageCreationParameters.h"
36	#include "WebPageGroup.h"	37	#include "WebPageGroup.h"
37	#include "WebPageProxy.h"	38	#include "WebPageProxy.h"
Lines 92-97 WebInspectorProxy::WebInspectorProxy(Web Source/WebKit2/UIProcess/WebInspectorProxy.cpp_sec2
92	, m_remoteInspectionPageId(0)	93	, m_remoteInspectionPageId(0)
93	#endif	94	#endif
94	{	95	{
		96	m_page->process()->addMessageReceiver(Messages::WebInspectorProxy::messageReceiverName(), m_page->pageID(), this);
95	}	97	}
96		98
97	WebInspectorProxy::~WebInspectorProxy()	99	WebInspectorProxy::~WebInspectorProxy()
Lines 105-110 void WebInspectorProxy::invalidate() Source/WebKit2/UIProcess/WebInspectorProxy.cpp_sec3
105	WebInspectorServer::shared().unregisterPage(m_remoteInspectionPageId);	107	WebInspectorServer::shared().unregisterPage(m_remoteInspectionPageId);
106	#endif	108	#endif
107		109
		110	m_page->process()->removeMessageReceiver(Messages::WebInspectorProxy::messageReceiverName(), m_page->pageID());
		111
108	m_page->close();	112	m_page->close();
109	didClose();	113	didClose();
110		114



#if ENABLE(INSPECTOR)

#include "APIObject.h"
#include "MessageReceiver.h"
#include <wtf/Forward.h>
#include <wtf/PassRefPtr.h>
#include <wtf/RefPtr.h>

class WebPageProxy;
struct WebPageCreationParameters;

class WebInspectorProxy : public APIObject, public CoreIPC::MessageReceiver {
public:
    static const Type APIType = TypeInspector;


    bool isProfilingPage() const { return m_isProfilingPage; }
    void togglePageProfiling();

#if ENABLE(INSPECTOR)
    // Implemented in generated WebInspectorProxyMessageReceiver.cpp
    void didReceiveWebInspectorProxyMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&);
    void didReceiveSyncWebInspectorProxyMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&, OwnPtr<CoreIPC::MessageEncoder>&);
#endif

    static bool isInspectorPage(WebPageProxy*);

    // Implemented the platform WebInspectorProxy file


    virtual Type type() const { return APIType; }

    // CoreIPC::MessageReceiver
    virtual void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&) OVERRIDE;
    virtual void didReceiveSyncMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&, OwnPtr<CoreIPC::MessageEncoder>&) OVERRIDE;

    WebPageProxy* platformCreateInspectorPage();
    void platformOpen();
    void platformDidClose();

Lines 22-28 Source/WebKit2/UIProcess/WebInspectorProxy.messages.in_sec1
- Source/WebKit2/UIProcess/WebInspectorProxy.messages.in -1 / +1 lines
22		22
23	#if ENABLE(INSPECTOR)	23	#if ENABLE(INSPECTOR)
24		24
25	messages -> WebInspectorProxy LegacyReceiver {	25	messages -> WebInspectorProxy {
26	CreateInspectorPage() -> (uint64_t inspectorPageID, WebKit::WebPageCreationParameters inspectorPageParameters)	26	CreateInspectorPage() -> (uint64_t inspectorPageID, WebKit::WebPageCreationParameters inspectorPageParameters)
27	DidLoadInspectorPage()	27	DidLoadInspectorPage()
28	DidClose()	28	DidClose()

Lines 72-77 Source/WebKit2/UIProcess/WebPageProxy.cpp_sec1
- Source/WebKit2/UIProcess/WebPageProxy.cpp -65 / +24 lines
72	#include "WebPageGroup.h"	72	#include "WebPageGroup.h"
73	#include "WebPageGroupData.h"	73	#include "WebPageGroupData.h"
74	#include "WebPageMessages.h"	74	#include "WebPageMessages.h"
		75	#include "WebPageProxyMessages.h"
75	#include "WebPopupItem.h"	76	#include "WebPopupItem.h"
76	#include "WebPopupMenuProxy.h"	77	#include "WebPopupMenuProxy.h"
77	#include "WebPreferences.h"	78	#include "WebPreferences.h"
Lines 250-258 WebPageProxy::WebPageProxy(PageClient* p Source/WebKit2/UIProcess/WebPageProxy.cpp_sec2
250		251
251	m_pageGroup->addPage(this);	252	m_pageGroup->addPage(this);
252		253
		254	#if ENABLE(INSPECTOR)
		255	m_inspector = WebInspectorProxy::create(this);
		256	#endif
		257	#if ENABLE(FULLSCREEN_API)
		258	m_fullScreenManager = WebFullScreenManagerProxy::create(this);
		259	#endif
253	#if ENABLE(VIBRATION)	260	#if ENABLE(VIBRATION)
254	m_vibration = WebVibrationProxy::create(this);	261	m_vibration = WebVibrationProxy::create(this);
255	#endif	262	#endif
		263
		264	m_process->addMessageReceiver(Messages::WebPageProxy::messageReceiverName(), m_pageID, this);
256	}	265	}
257		266
258	WebPageProxy::~WebPageProxy()	267	WebPageProxy::~WebPageProxy()
Lines 385-395 void WebPageProxy::reattachToWebProcess( Source/WebKit2/UIProcess/WebPageProxy.cpp_sec3
385	else	394	else
386	m_process = m_process->context()->createNewWebProcessRespectingProcessCountLimit();	395	m_process = m_process->context()->createNewWebProcessRespectingProcessCountLimit();
387	m_process->addExistingWebPage(this, m_pageID);	396	m_process->addExistingWebPage(this, m_pageID);
		397	m_process->addMessageReceiver(Messages::WebPageProxy::messageReceiverName(), m_pageID, this);
388		398
389	initializeWebPage();	399	initializeWebPage();
390		400
391	m_pageClient->didRelaunchProcess();	401	m_pageClient->didRelaunchProcess();
392	m_drawingArea->waitForBackingStoreUpdateOnNextPaint();	402	m_drawingArea->waitForBackingStoreUpdateOnNextPaint();
		403
		404	#if ENABLE(INSPECTOR)
		405	m_inspector = WebInspectorProxy::create(this);
		406	#endif
		407	#if ENABLE(FULLSCREEN_API)
		408	m_fullScreenManager = WebFullScreenManagerProxy::create(this);
		409	#endif
393	}	410	}
394		411
395	void WebPageProxy::reattachToWebProcessWithItem(WebBackForwardListItem* item)	412	void WebPageProxy::reattachToWebProcessWithItem(WebBackForwardListItem* item)
Lines 526-531 void WebPageProxy::close() Source/WebKit2/UIProcess/WebPageProxy.cpp_sec4
526		543
527	m_process->send(Messages::WebPage::Close(), m_pageID);	544	m_process->send(Messages::WebPage::Close(), m_pageID);
528	m_process->removeWebPage(m_pageID);	545	m_process->removeWebPage(m_pageID);
		546	m_process->removeMessageReceiver(Messages::WebPageProxy::messageReceiverName(), m_pageID);
529	}	547	}
530		548
531	bool WebPageProxy::tryClose()	549	bool WebPageProxy::tryClose()
Lines 1933-1991 void WebPageProxy::preferencesDidChange( Source/WebKit2/UIProcess/WebPageProxy.cpp_sec5
1933	m_process->send(Messages::WebPage::PreferencesDidChange(pageGroup()->preferences()->store()), m_pageID, m_isPerformingDOMPrintOperation ? CoreIPC::DispatchMessageEvenWhenWaitingForSyncReply : 0);	1951	m_process->send(Messages::WebPage::PreferencesDidChange(pageGroup()->preferences()->store()), m_pageID, m_isPerformingDOMPrintOperation ? CoreIPC::DispatchMessageEvenWhenWaitingForSyncReply : 0);
1934	}	1952	}
1935		1953
1936	void WebPageProxy::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder)
1937	{
1938	if (decoder.messageReceiverName() == Messages::DrawingAreaProxy::messageReceiverName()) {
1939	m_drawingArea->didReceiveDrawingAreaProxyMessage(connection, decoder);
1940	return;
1941	}
1942
1943	#if USE(COORDINATED_GRAPHICS)
1944	if (decoder.messageReceiverName() == Messages::CoordinatedLayerTreeHostProxy::messageReceiverName()) {
1945	m_drawingArea->didReceiveCoordinatedLayerTreeHostProxyMessage(connection, decoder);
1946	return;
1947	}
1948	#endif
1949
1950	#if ENABLE(INSPECTOR)
1951	if (decoder.messageReceiverName() == Messages::WebInspectorProxy::messageReceiverName()) {
1952	if (WebInspectorProxy* inspector = this->inspector())
1953	inspector->didReceiveWebInspectorProxyMessage(connection, decoder);
1954	return;
1955	}
1956	#endif
1957
1958	#if ENABLE(FULLSCREEN_API)
1959	if (decoder.messageReceiverName() == Messages::WebFullScreenManagerProxy::messageReceiverName()) {
1960	fullScreenManager()->didReceiveMessage(connection, decoder);
1961	return;
1962	}
1963	#endif
1964
1965	didReceiveWebPageProxyMessage(connection, decoder);
1966	}
1967
1968	void WebPageProxy::didReceiveSyncMessage(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder, OwnPtr<CoreIPC::MessageEncoder>& replyEncoder)
1969	{
1970	#if ENABLE(INSPECTOR)
1971	if (decoder.messageReceiverName() == Messages::WebInspectorProxy::messageReceiverName()) {
1972	if (WebInspectorProxy* inspector = this->inspector())
1973	inspector->didReceiveSyncWebInspectorProxyMessage(connection, decoder, replyEncoder);
1974	return;
1975	}
1976	#endif
1977
1978	#if ENABLE(FULLSCREEN_API)
1979	if (decoder.messageReceiverName() == Messages::WebFullScreenManagerProxy::messageReceiverName()) {
1980	fullScreenManager()->didReceiveSyncMessage(connection, decoder, replyEncoder);
1981	return;
1982	}
1983	#endif
1984
1985	// FIXME: Do something with reply.
1986	didReceiveSyncWebPageProxyMessage(connection, decoder, replyEncoder);
1987	}
1988
1989	void WebPageProxy::didCreateMainFrame(uint64_t frameID)	1954	void WebPageProxy::didCreateMainFrame(uint64_t frameID)
1990	{	1955	{
1991	MESSAGE_CHECK(!m_mainFrame);	1956	MESSAGE_CHECK(!m_mainFrame);
Lines 2846-2853 WebInspectorProxy* WebPageProxy::inspect Source/WebKit2/UIProcess/WebPageProxy.cpp_sec6
2846	{	2811	{
2847	if (isClosed() \|\| !isValid())	2812	if (isClosed() \|\| !isValid())
2848	return 0;	2813	return 0;
2849	if (!m_inspector)
2850	m_inspector = WebInspectorProxy::create(this);
2851	return m_inspector.get();	2814	return m_inspector.get();
2852	}	2815	}
2853		2816
Lines 2856-2863 WebInspectorProxy* WebPageProxy::inspect Source/WebKit2/UIProcess/WebPageProxy.cpp_sec7
2856	#if ENABLE(FULLSCREEN_API)	2819	#if ENABLE(FULLSCREEN_API)
2857	WebFullScreenManagerProxy* WebPageProxy::fullScreenManager()	2820	WebFullScreenManagerProxy* WebPageProxy::fullScreenManager()
2858	{	2821	{
2859	if (!m_fullScreenManager)
2860	m_fullScreenManager = WebFullScreenManagerProxy::create(this);
2861	return m_fullScreenManager.get();	2822	return m_fullScreenManager.get();
2862	}	2823	}
2863	#endif	2824	#endif
Lines 3612-3628 void WebPageProxy::processDidCrash() Source/WebKit2/UIProcess/WebPageProxy.cpp_sec8
3612	m_drawingArea = nullptr;	3573	m_drawingArea = nullptr;
3613		3574
3614	#if ENABLE(INSPECTOR)	3575	#if ENABLE(INSPECTOR)
3615	if (m_inspector) {	3576	m_inspector->invalidate();
3616	m_inspector->invalidate();	3577	m_inspector = nullptr;
3617	m_inspector = nullptr;
3618	}
3619	#endif	3578	#endif
3620		3579
3621	#if ENABLE(FULLSCREEN_API)	3580	#if ENABLE(FULLSCREEN_API)
3622	if (m_fullScreenManager) {	3581	m_fullScreenManager->invalidate();
3623	m_fullScreenManager->invalidate();	3582	m_fullScreenManager = nullptr;
3624	m_fullScreenManager = nullptr;
3625	}
3626	#endif	3583	#endif
3627		3584
3628	#if ENABLE(VIBRATION)	3585	#if ENABLE(VIBRATION)
Lines 3719-3724 void WebPageProxy::processDidCrash() Source/WebKit2/UIProcess/WebPageProxy.cpp_sec9
3719	dismissCorrectionPanel(ReasonForDismissingAlternativeTextIgnored);	3676	dismissCorrectionPanel(ReasonForDismissingAlternativeTextIgnored);
3720	m_pageClient->dismissDictionaryLookupPanel();	3677	m_pageClient->dismissDictionaryLookupPanel();
3721	#endif	3678	#endif
		3679
		3680	m_process->removeMessageReceiver(Messages::WebPageProxy::messageReceiverName(), m_pageID);
3722	}	3681	}
3723		3682
3724	WebPageCreationParameters WebPageProxy::creationParameters() const	3683	WebPageCreationParameters WebPageProxy::creationParameters() const



#include "DrawingAreaProxy.h"
#include "EditorState.h"
#include "GeolocationPermissionRequestManagerProxy.h"
#if ENABLE(TOUCH_EVENTS)
#include "NativeWebTouchEvent.h"
#endif
#if PLATFORM(QT)
#include "QtNetworkRequestData.h"
#endif
#include "LayerTreeContext.h"
#include "NotificationPermissionRequestManagerProxy.h"
#include "PlatformProcessIdentifier.h"

#include <WebCore/DragSession.h>
#endif

#if ENABLE(TOUCH_EVENTS)
#include "NativeWebTouchEvent.h"
#endif

#if PLATFORM(EFL)
#include <Evas.h>
#endif

#if PLATFORM(QT)
#include "QtNetworkRequestData.h"
#endif

namespace CoreIPC {
    class ArgumentDecoder;
    class Connection;

#if ENABLE(INPUT_TYPE_COLOR)
    , public WebColorChooserProxy::Client
#endif
    , public WebPopupMenuProxy::Client
    , public CoreIPC::MessageReceiver {
public:
    static const Type APIType = TypePage;


#endif
#endif

    void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&);
    void didReceiveSyncMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&, OwnPtr<CoreIPC::MessageEncoder>&);

    void processDidBecomeUnresponsive();
    void interactionOccurredWhileProcessUnresponsive();
    void processDidBecomeResponsive();


    virtual Type type() const { return APIType; }

    // CoreIPC::MessageReceiver
    virtual void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&) OVERRIDE;
    virtual void didReceiveSyncMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&, OwnPtr<CoreIPC::MessageEncoder>&) OVERRIDE;

    // WebPopupMenuProxy::Client
    virtual void valueChangedForPopupMenu(WebPopupMenuProxy*, int32_t newSelectedIndex);
    virtual void setTextFromItemForPopupMenu(WebPopupMenuProxy*, int32_t index);

Lines 20-26 Source/WebKit2/UIProcess/WebPageProxy.messages.in_sec1
- Source/WebKit2/UIProcess/WebPageProxy.messages.in -1 / +1 lines
20	# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE	20	# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
21	# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	21	# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
22		22
23	messages -> WebPageProxy LegacyReceiver {	23	messages -> WebPageProxy {
24	# UI messages	24	# UI messages
25	CreateNewPage(WebCore::ResourceRequest request, WebCore::WindowFeatures windowFeatures, uint32_t modifiers, int32_t mouseButton) -> (uint64_t newPageID, WebKit::WebPageCreationParameters newPageParameters)	25	CreateNewPage(WebCore::ResourceRequest request, WebCore::WindowFeatures windowFeatures, uint32_t modifiers, int32_t mouseButton) -> (uint64_t newPageID, WebKit::WebPageCreationParameters newPageParameters)
26	ShowPage()	26	ShowPage()



    if (m_context->dispatchMessage(connection, decoder))
        return;

    if (decoder.messageReceiverName() == Messages::WebProcessProxy::messageReceiverName()) {
        didReceiveWebProcessProxyMessage(connection, decoder);
        return;
    }

#if ENABLE(CUSTOM_PROTOCOLS)
    if (decoder.messageReceiverName() == Messages::CustomProtocolManagerProxy::messageReceiverName()) {
#if ENABLE(NETWORK_PROCESS)

    }
#endif

    ASSERT(decoder.messageReceiverName() == Messages::WebProcessProxy::messageReceiverName());
    didReceiveWebProcessProxyMessage(connection, decoder);
        return;

    WebPageProxy* pageProxy = webPage(pageID);
    if (!pageProxy)
        return;
    
    pageProxy->didReceiveMessage(connection, decoder);
}

void WebProcessProxy::didReceiveSyncMessage(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder, OwnPtr<CoreIPC::MessageEncoder>& replyEncoder)

    if (m_context->dispatchSyncMessage(connection, decoder, replyEncoder))
        return;

    ASSERT(decoder.messageReceiverName() == Messages::WebProcessProxy::messageReceiverName());
    didReceiveSyncWebProcessProxyMessage(connection, decoder, replyEncoder);
        return;
    }

    uint64_t pageID = decoder.destinationID();
    if (!pageID)
        return;
    
    WebPageProxy* pageProxy = webPage(pageID);
    if (!pageProxy)
        return;
    
    pageProxy->didReceiveSyncMessage(connection, decoder, replyEncoder);
}

void WebProcessProxy::didReceiveMessageOnConnectionWorkQueue(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder, bool& didHandleMessage)



#include "CoordinatedLayerTreeHostProxy.h"

#include "CoordinatedLayerTreeHostMessages.h"
#include "CoordinatedLayerTreeHostProxyMessages.h"
#include "WebCoreArgumentCoders.h"
#include "WebPageProxy.h"
#include "WebProcessProxy.h"

    : m_drawingAreaProxy(drawingAreaProxy)
    , m_scene(adoptRef(new CoordinatedGraphicsScene(this)))
{
    m_drawingAreaProxy->page()->process()->addMessageReceiver(Messages::CoordinatedLayerTreeHostProxy::messageReceiverName(), m_drawingAreaProxy->page()->pageID(), this);
}

CoordinatedLayerTreeHostProxy::~CoordinatedLayerTreeHostProxy()
{
    m_drawingAreaProxy->page()->process()->removeMessageReceiver(Messages::CoordinatedLayerTreeHostProxy::messageReceiverName(), m_drawingAreaProxy->page()->pageID());
    m_scene->detach();
}





namespace WebKit {

class CoordinatedLayerTreeHostProxy : public WebCore::CoordinatedGraphicsSceneClient, public CoreIPC::MessageReceiver {
    WTF_MAKE_NONCOPYABLE(CoordinatedLayerTreeHostProxy);
    WTF_MAKE_FAST_ALLOCATED;
public:

    void updateImageBacking(WebCore::CoordinatedImageBackingID, const WebCoordinatedSurface::Handle&);
    void clearImageBackingContents(WebCore::CoordinatedImageBackingID);
    void removeImageBacking(WebCore::CoordinatedImageBackingID);
    void didReceiveCoordinatedLayerTreeHostProxyMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&);
    void didChangeScrollPosition(const WebCore::FloatPoint& position);
#if USE(GRAPHICS_SURFACE)
    void createCanvas(WebCore::CoordinatedLayerID, const WebCore::IntSize&, const WebCore::GraphicsSurfaceToken&);

protected:
    void dispatchUpdate(const Function<void()>&);

    // CoreIPC::MessageReceiver
    virtual void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&) OVERRIDE;

    DrawingAreaProxy* m_drawingAreaProxy;
    RefPtr<WebCore::CoordinatedGraphicsScene> m_scene;
    WebCore::FloatRect m_lastSentVisibleRect;

Lines 18-24 Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedLayerTreeHostProxy.messages.in_sec1
- Source/WebKit2/UIProcess/CoordinatedGraphics/CoordinatedLayerTreeHostProxy.messages.in -1 / +1 lines
18	#	18	#
19		19
20	#if USE(COORDINATED_GRAPHICS)	20	#if USE(COORDINATED_GRAPHICS)
21	messages -> CoordinatedLayerTreeHostProxy LegacyReceiver {	21	messages -> CoordinatedLayerTreeHostProxy {
22	SetCompositingLayerState(uint32_t id, WebCore::CoordinatedLayerInfo layerInfo)	22	SetCompositingLayerState(uint32_t id, WebCore::CoordinatedLayerInfo layerInfo)
23	SetCompositingLayerChildren(uint32_t id, Vector<uint32_t> children)	23	SetCompositingLayerChildren(uint32_t id, Vector<uint32_t> children)
24	#if ENABLE(CSS_FILTERS)	24	#if ENABLE(CSS_FILTERS)

Lines 31-36 Source/WebKit2/UIProcess/mac/WebFullScreenManagerProxyMac.mm_sec1
- Source/WebKit2/UIProcess/mac/WebFullScreenManagerProxyMac.mm +5 lines
31	#import "LayerTreeContext.h"	31	#import "LayerTreeContext.h"
32	#import "WKFullScreenWindowController.h"	32	#import "WKFullScreenWindowController.h"
33	#import "WKViewInternal.h"	33	#import "WKViewInternal.h"
		34	#import "WebFullScreenManagerProxyMessages.h"
		35	#import "WebPageProxy.h"
		36	#import "WebProcessProxy.h"
34	#import <WebCore/IntRect.h>	37	#import <WebCore/IntRect.h>
35		38
36	using namespace WebCore;	39	using namespace WebCore;
Lines 39-44 namespace WebKit { Source/WebKit2/UIProcess/mac/WebFullScreenManagerProxyMac.mm_sec2
39		42
40	void WebFullScreenManagerProxy::invalidate()	43	void WebFullScreenManagerProxy::invalidate()
41	{	44	{
		45	m_page->process()->removeMessageReceiver(Messages::WebFullScreenManagerProxy::messageReceiverName(), m_page->pageID());
		46
42	if (!m_webView)	47	if (!m_webView)
43	return;	48	return;
44		49

Return to Bug 108785

Lines 370-387 void DrawingAreaProxyImpl::enterAccelera Source/WebKit2/UIProcess/DrawingAreaProxyImpl.cpp_sec1
- Source/WebKit2/UIProcess/DrawingAreaProxyImpl.cpp -7 lines
370	}	370	}
371		371
372	#if USE(COORDINATED_GRAPHICS)	372	#if USE(COORDINATED_GRAPHICS)
373	void DrawingAreaProxyImpl::didReceiveCoordinatedLayerTreeHostProxyMessage(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder)
374	{
375	if (m_coordinatedLayerTreeHostProxy)
376	m_coordinatedLayerTreeHostProxy->didReceiveCoordinatedLayerTreeHostProxyMessage(connection, decoder);
377	}
378
379	void DrawingAreaProxyImpl::setVisibleContentsRect(const WebCore::FloatRect& visibleContentsRect, const WebCore::FloatPoint& trajectoryVector)	373	void DrawingAreaProxyImpl::setVisibleContentsRect(const WebCore::FloatRect& visibleContentsRect, const WebCore::FloatPoint& trajectoryVector)
380	{	374	{
381	if (m_coordinatedLayerTreeHostProxy)	375	if (m_coordinatedLayerTreeHostProxy)
382	m_coordinatedLayerTreeHostProxy->setVisibleContentsRect(visibleContentsRect, trajectoryVector);	376	m_coordinatedLayerTreeHostProxy->setVisibleContentsRect(visibleContentsRect, trajectoryVector);
383	}	377	}
384
385	#endif	378	#endif
386		379
387	void DrawingAreaProxyImpl::exitAcceleratedCompositingMode()	380	void DrawingAreaProxyImpl::exitAcceleratedCompositingMode()

Lines 1-3 Source/WebKit2/ChangeLog_sec1
- Source/WebKit2/ChangeLog +48 lines
		1	2013-02-03 Sam Weinig <sam@webkit.org>
		2
		3	Make WebPageProxy and sub-objects MessageReceivers
		4	https://bugs.webkit.org/show_bug.cgi?id=108785
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	* UIProcess/CoordinatedGraphics/CoordinatedLayerTreeHostProxy.cpp:
		9	(WebKit::CoordinatedLayerTreeHostProxy::CoordinatedLayerTreeHostProxy):
		10	(WebKit::CoordinatedLayerTreeHostProxy::~CoordinatedLayerTreeHostProxy):
		11	* UIProcess/CoordinatedGraphics/CoordinatedLayerTreeHostProxy.h:
		12	(CoordinatedLayerTreeHostProxy):
		13	* UIProcess/CoordinatedGraphics/CoordinatedLayerTreeHostProxy.messages.in:
		14	* UIProcess/DrawingAreaProxy.cpp:
		15	(WebKit::DrawingAreaProxy::DrawingAreaProxy):
		16	(WebKit::DrawingAreaProxy::~DrawingAreaProxy):
		17	(WebKit::DrawingAreaProxy::contentsRect):
		18	* UIProcess/DrawingAreaProxy.h:
		19	(WebKit::DrawingAreaProxy::setVisibleContentsRect):
		20	* UIProcess/DrawingAreaProxy.messages.in:
		21	* UIProcess/DrawingAreaProxyImpl.cpp:
		22	(WebKit::DrawingAreaProxyImpl::setVisibleContentsRect):
		23	* UIProcess/DrawingAreaProxyImpl.h:
		24	* UIProcess/WebFullScreenManagerProxy.cpp:
		25	(WebKit::WebFullScreenManagerProxy::WebFullScreenManagerProxy):
		26	* UIProcess/WebFullScreenManagerProxy.h:
		27	(WebFullScreenManagerProxy):
		28	* UIProcess/WebFullScreenManagerProxy.messages.in:
		29	* UIProcess/WebInspectorProxy.cpp:
		30	(WebKit::WebInspectorProxy::WebInspectorProxy):
		31	(WebKit::WebInspectorProxy::invalidate):
		32	* UIProcess/WebInspectorProxy.h:
		33	* UIProcess/WebInspectorProxy.messages.in:
		34	* UIProcess/WebPageProxy.cpp:
		35	(WebKit::WebPageProxy::WebPageProxy):
		36	(WebKit::WebPageProxy::reattachToWebProcess):
		37	(WebKit::WebPageProxy::close):
		38	(WebKit::WebPageProxy::inspector):
		39	(WebKit::WebPageProxy::fullScreenManager):
		40	(WebKit::WebPageProxy::processDidCrash):
		41	* UIProcess/WebPageProxy.h:
		42	* UIProcess/WebPageProxy.messages.in:
		43	* UIProcess/WebProcessProxy.cpp:
		44	(WebKit::WebProcessProxy::didReceiveMessage):
		45	(WebKit::WebProcessProxy::didReceiveSyncMessage):
		46	* UIProcess/mac/WebFullScreenManagerProxyMac.mm:
		47	(WebKit::WebFullScreenManagerProxy::invalidate):
		48
1	2013-02-03 Joanmarie Diggs <jdiggs@igalia.com>	49	2013-02-03 Joanmarie Diggs <jdiggs@igalia.com>
2		50
3	[GTK] Make distcheck fails	51	[GTK] Make distcheck fails

Lines 26-32 Source/WebKit2/UIProcess/DrawingAreaProxy.cpp_sec1
- Source/WebKit2/UIProcess/DrawingAreaProxy.cpp -4 / +4 lines
26	#include "config.h"	26	#include "config.h"
27	#include "DrawingAreaProxy.h"	27	#include "DrawingAreaProxy.h"
28		28
		29	#include "DrawingAreaProxyMessages.h"
29	#include "WebPageProxy.h"	30	#include "WebPageProxy.h"
		31	#include "WebProcessProxy.h"
30		32
31	#if USE(COORDINATED_GRAPHICS)	33	#if USE(COORDINATED_GRAPHICS)
32	#include "CoordinatedLayerTreeHostProxy.h"	34	#include "CoordinatedLayerTreeHostProxy.h"
Lines 41-50 DrawingAreaProxy::DrawingAreaProxy(Drawi Source/WebKit2/UIProcess/DrawingAreaProxy.cpp_sec2
41	, m_webPageProxy(webPageProxy)	43	, m_webPageProxy(webPageProxy)
42	, m_size(webPageProxy->viewSize())	44	, m_size(webPageProxy->viewSize())
43	{	45	{
		46	m_webPageProxy->process()->addMessageReceiver(Messages::DrawingAreaProxy::messageReceiverName(), webPageProxy->pageID(), this);
44	}	47	}
45		48
46	DrawingAreaProxy::~DrawingAreaProxy()	49	DrawingAreaProxy::~DrawingAreaProxy()
47	{	50	{
		51	m_webPageProxy->process()->removeMessageReceiver(Messages::DrawingAreaProxy::messageReceiverName(), m_webPageProxy->pageID());
48	}	52	}
49		53
50	void DrawingAreaProxy::setSize(const IntSize& size, const IntSize& scrollOffset)	54	void DrawingAreaProxy::setSize(const IntSize& size, const IntSize& scrollOffset)
Lines 67-76 WebCore::IntRect DrawingAreaProxy::conte Source/WebKit2/UIProcess/DrawingAreaProxy.cpp_sec3
67	{	71	{
68	return IntRect(IntPoint::zero(), m_webPageProxy->viewSize());	72	return IntRect(IntPoint::zero(), m_webPageProxy->viewSize());
69	}	73	}
70
71	void DrawingAreaProxy::didReceiveCoordinatedLayerTreeHostProxyMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&)
72	{
73	}
74	#endif	74	#endif
75		75
76	} // namespace WebKit	76	} // namespace WebKit

Lines 29-49 Source/WebKit2/UIProcess/DrawingAreaProxy.h_sec1
- Source/WebKit2/UIProcess/DrawingAreaProxy.h -13 / +5 lines
29		29
30	#include "BackingStore.h"	30	#include "BackingStore.h"
31	#include "DrawingAreaInfo.h"	31	#include "DrawingAreaInfo.h"
		32	#include "MessageReceiver.h"
32	#include <WebCore/FloatPoint.h>	33	#include <WebCore/FloatPoint.h>
33	#include <WebCore/IntRect.h>	34	#include <WebCore/IntRect.h>
34	#include <WebCore/IntSize.h>	35	#include <WebCore/IntSize.h>
35	#include <stdint.h>	36	#include <stdint.h>
36	#include <wtf/Noncopyable.h>	37	#include <wtf/Noncopyable.h>
37		38
38	namespace CoreIPC {
39	class Connection;
40	class MessageDecoder;
41	}
42
43	namespace WebCore {
44	class TransformationMatrix;
45	}
46
47	namespace WebKit {	39	namespace WebKit {
48		40
49	class LayerTreeContext;	41	class LayerTreeContext;
Lines 51-57 class CoordinatedLayerTreeHostProxy; Source/WebKit2/UIProcess/DrawingAreaProxy.h_sec2
51	class UpdateInfo;	43	class UpdateInfo;
52	class WebPageProxy;	44	class WebPageProxy;
53		45
54	class DrawingAreaProxy {	46	class DrawingAreaProxy : public CoreIPC::MessageReceiver {
55	WTF_MAKE_NONCOPYABLE(DrawingAreaProxy);	47	WTF_MAKE_NONCOPYABLE(DrawingAreaProxy);
56		48
57	public:	49	public:
Lines 59-66 public: Source/WebKit2/UIProcess/DrawingAreaProxy.h_sec3
59		51
60	DrawingAreaType type() const { return m_type; }	52	DrawingAreaType type() const { return m_type; }
61		53
62	void didReceiveDrawingAreaProxyMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&);
63
64	virtual void deviceScaleFactorDidChange() = 0;	54	virtual void deviceScaleFactorDidChange() = 0;
65		55
66	// FIXME: These should be pure virtual.	56	// FIXME: These should be pure virtual.
Lines 86-92 public: Source/WebKit2/UIProcess/DrawingAreaProxy.h_sec4
86	virtual WebCore::IntRect contentsRect() const;	76	virtual WebCore::IntRect contentsRect() const;
87	CoordinatedLayerTreeHostProxy* coordinatedLayerTreeHostProxy() const { return m_coordinatedLayerTreeHostProxy.get(); }	77	CoordinatedLayerTreeHostProxy* coordinatedLayerTreeHostProxy() const { return m_coordinatedLayerTreeHostProxy.get(); }
88	virtual void setVisibleContentsRect(const WebCore::FloatRect& /* visibleContentsRect /, const WebCore::FloatPoint& / trajectoryVector */) { }	78	virtual void setVisibleContentsRect(const WebCore::FloatRect& /* visibleContentsRect /, const WebCore::FloatPoint& / trajectoryVector */) { }
89	virtual void didReceiveCoordinatedLayerTreeHostProxyMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&);
90		79
91	WebPageProxy* page() { return m_webPageProxy; }	80	WebPageProxy* page() { return m_webPageProxy; }
92	#endif	81	#endif
Lines 106-111 protected: Source/WebKit2/UIProcess/DrawingAreaProxy.h_sec5
106	private:	95	private:
107	virtual void sizeDidChange() = 0;	96	virtual void sizeDidChange() = 0;
108		97
		98	// CoreIPC::MessageReceiver
		99	virtual void didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageDecoder&) OVERRIDE;
		100
109	// CoreIPC message handlers.	101	// CoreIPC message handlers.
110	// FIXME: These should be pure virtual.	102	// FIXME: These should be pure virtual.
111	virtual void update(uint64_t /* backingStoreStateID */, const UpdateInfo&) { }	103	virtual void update(uint64_t /* backingStoreStateID */, const UpdateInfo&) { }

Lines 43-48 WebFullScreenManagerProxy::WebFullScreen Source/WebKit2/UIProcess/WebFullScreenManagerProxy.cpp_sec1
- Source/WebKit2/UIProcess/WebFullScreenManagerProxy.cpp -10 / +1 lines
43	: m_page(page)	43	: m_page(page)
44	, m_webView(0)	44	, m_webView(0)
45	{	45	{
		46	m_page->process()->addMessageReceiver(Messages::WebFullScreenManagerProxy::messageReceiverName(), m_page->pageID(), this);
46	}	47	}
47		48
48	WebFullScreenManagerProxy::~WebFullScreenManagerProxy()	49	WebFullScreenManagerProxy::~WebFullScreenManagerProxy()
Lines 54-69 void WebFullScreenManagerProxy::setWebVi Source/WebKit2/UIProcess/WebFullScreenManagerProxy.cpp_sec2
54	m_webView = webView;	55	m_webView = webView;
55	}	56	}
56		57
57	void WebFullScreenManagerProxy::didReceiveMessage(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder)
58	{
59	didReceiveWebFullScreenManagerProxyMessage(connection, decoder);
60	}
61
62	void WebFullScreenManagerProxy::didReceiveSyncMessage(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder, OwnPtr<CoreIPC::MessageEncoder>& replyEncoder)
63	{
64	didReceiveSyncWebFullScreenManagerProxyMessage(connection, decoder, replyEncoder);
65	}
66
67	void WebFullScreenManagerProxy::willEnterFullScreen()	58	void WebFullScreenManagerProxy::willEnterFullScreen()
68	{	59	{
69	m_page->process()->send(Messages::WebFullScreenManager::WillEnterFullScreen(), m_page->pageID());	60	m_page->process()->send(Messages::WebFullScreenManager::WillEnterFullScreen(), m_page->pageID());

Lines 405-415 void WebProcessProxy::didReceiveMessage( Source/WebKit2/UIProcess/WebProcessProxy.cpp_sec1
- Source/WebKit2/UIProcess/WebProcessProxy.cpp -28 / +4 lines
405	if (m_context->dispatchMessage(connection, decoder))	405	if (m_context->dispatchMessage(connection, decoder))
406	return;	406	return;
407		407
408	if (decoder.messageReceiverName() == Messages::WebProcessProxy::messageReceiverName()) {
409	didReceiveWebProcessProxyMessage(connection, decoder);
410	return;
411	}
412
413	#if ENABLE(CUSTOM_PROTOCOLS)	408	#if ENABLE(CUSTOM_PROTOCOLS)
414	if (decoder.messageReceiverName() == Messages::CustomProtocolManagerProxy::messageReceiverName()) {	409	if (decoder.messageReceiverName() == Messages::CustomProtocolManagerProxy::messageReceiverName()) {
415	#if ENABLE(NETWORK_PROCESS)	410	#if ENABLE(NETWORK_PROCESS)
Lines 420-434 void WebProcessProxy::didReceiveMessage( Source/WebKit2/UIProcess/WebProcessProxy.cpp_sec2
420	}	415	}
421	#endif	416	#endif
422		417
423	uint64_t pageID = decoder.destinationID();	418	ASSERT(decoder.messageReceiverName() == Messages::WebProcessProxy::messageReceiverName());
424	if (!pageID)	419	didReceiveWebProcessProxyMessage(connection, decoder);
425	return;
426
427	WebPageProxy* pageProxy = webPage(pageID);
428	if (!pageProxy)
429	return;
430
431	pageProxy->didReceiveMessage(connection, decoder);
432	}	420	}
433		421
434	void WebProcessProxy::didReceiveSyncMessage(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder, OwnPtr<CoreIPC::MessageEncoder>& replyEncoder)	422	void WebProcessProxy::didReceiveSyncMessage(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder, OwnPtr<CoreIPC::MessageEncoder>& replyEncoder)
Lines 439-458 void WebProcessProxy::didReceiveSyncMess Source/WebKit2/UIProcess/WebProcessProxy.cpp_sec3
439	if (m_context->dispatchSyncMessage(connection, decoder, replyEncoder))	427	if (m_context->dispatchSyncMessage(connection, decoder, replyEncoder))
440	return;	428	return;
441		429
442	if (decoder.messageReceiverName() == Messages::WebProcessProxy::messageReceiverName()) {	430	ASSERT(decoder.messageReceiverName() == Messages::WebProcessProxy::messageReceiverName());
443	didReceiveSyncWebProcessProxyMessage(connection, decoder, replyEncoder);	431	didReceiveSyncWebProcessProxyMessage(connection, decoder, replyEncoder);
444	return;
445	}
446
447	uint64_t pageID = decoder.destinationID();
448	if (!pageID)
449	return;
450
451	WebPageProxy* pageProxy = webPage(pageID);
452	if (!pageProxy)
453	return;
454
455	pageProxy->didReceiveSyncMessage(connection, decoder, replyEncoder);
456	}	432	}
457		433
458	void WebProcessProxy::didReceiveMessageOnConnectionWorkQueue(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder, bool& didHandleMessage)	434	void WebProcessProxy::didReceiveMessageOnConnectionWorkQueue(CoreIPC::Connection* connection, CoreIPC::MessageDecoder& decoder, bool& didHandleMessage)