[DO NOT COMMIT] Random hacks to unblock work on replication.

Source/web/WebRemoteFrameImpl.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "web/WebRemoteFrameImpl.h"
 
 #include "core/frame/FrameOwner.h"
 #include "core/frame/RemoteFrame.h"
+#include "core/html/HTMLFrameOwnerElement.h"
 #include "core/page/Page.h"
+#include "core/rendering/RenderLayer.h"
 #include "public/platform/WebFloatRect.h"
+#include "public/platform/WebLayer.h"
 #include "public/platform/WebRect.h"
 #include "public/web/WebDocument.h"
 #include "public/web/WebPerformance.h"
 #include "public/web/WebRange.h"
 #include "web/WebLocalFrameImpl.h"
 #include "web/WebViewImpl.h"
 #include <v8/include/v8.h>
 
 using namespace WebCore;
 
@@ skipping 129 matching lines @@
 }
 
 WebVector<WebIconURL> WebRemoteFrameImpl::iconURLs(int iconTypesMask) const
 {
     ASSERT_NOT_REACHED();
     return WebVector<WebIconURL>();
 }
 
 void WebRemoteFrameImpl::setIsRemote(bool)
 {
+
     ASSERT_NOT_REACHED();
 }
 
-void WebRemoteFrameImpl::setRemoteWebLayer(WebLayer*)
+void WebRemoteFrameImpl::setRemoteWebLayer(WebLayer* webLayer)
 {
-    ASSERT_NOT_REACHED();
+    if (!frame())
+        return;
+
+    if (frame()->remotePlatformLayer())
+        GraphicsLayer::unregisterContentsLayer(frame()->remotePlatformLayer());
+    if (webLayer)
+        GraphicsLayer::registerContentsLayer(webLayer);
+    frame()->setRemotePlatformLayer(webLayer);
+
+    // FIXME: This should be moved to WebRemoteFrame.
+    frame()->deprecatedLocalOwner()->setNeedsCompositingUpdate();
+    if (RenderPart* renderer = frame()->ownerRenderer())
+        renderer->layer()->updateSelfPaintingLayer();
 }
 
 void WebRemoteFrameImpl::setPermissionClient(WebPermissionClient*)
 {
     ASSERT_NOT_REACHED();
 }
 
 void WebRemoteFrameImpl::setSharedWorkerRepositoryClient(WebSharedWorkerRepositoryClient*)
 {
     ASSERT_NOT_REACHED();
@@ skipping 64 matching lines @@
 }
 
 void WebRemoteFrameImpl::removeChild(WebFrame* frame)
 {
     WebFrame::removeChild(frame);
     m_ownersForChildren.remove(frame);
 }
 
 WebDocument WebRemoteFrameImpl::document() const
 {
-    ASSERT_NOT_REACHED();
+    //ASSERT_NOT_REACHED();
     return WebDocument();
 }
 
 WebPerformance WebRemoteFrameImpl::performance() const
 {
     ASSERT_NOT_REACHED();
     return WebPerformance();
 }
 
 bool WebRemoteFrameImpl::dispatchBeforeUnloadEvent()
@@ skipping 238 matching lines @@
 }
 
 bool WebRemoteFrameImpl::isCommandEnabled(const WebString&) const
 {
     ASSERT_NOT_REACHED();
     return false;
 }
 
 void WebRemoteFrameImpl::enableContinuousSpellChecking(bool)
 {
-    ASSERT_NOT_REACHED();
+    //ASSERT_NOT_REACHED();
 }
 
 bool WebRemoteFrameImpl::isContinuousSpellCheckingEnabled() const
 {
-    ASSERT_NOT_REACHED();
+    //ASSERT_NOT_REACHED();
     return false;
 }
 
 void WebRemoteFrameImpl::requestTextChecking(const WebElement&)
 {
     ASSERT_NOT_REACHED();
 }
 
 void WebRemoteFrameImpl::replaceMisspelledRange(const WebString&)
 {
@@ skipping 260 matching lines @@
 WebLocalFrame* WebRemoteFrameImpl::createLocalChild(const WebString& name, WebFrameClient* client)
 {
     WebLocalFrameImpl* child = toWebLocalFrameImpl(WebLocalFrame::create(client));
     HashMap<WebFrame*, OwnPtr<FrameOwner> >::AddResult result =
         m_ownersForChildren.add(child, adoptPtr(new RemoteBridgeFrameOwner(child)));
     appendChild(child);
     // FIXME: currently this calls LocalFrame::init() on the created LocalFrame, which may
     // result in the browser observing two navigations to about:blank (one from the initial
     // frame creation, and one from swapping it into the remote process). FrameLoader might
     // need a special initialization function for this case to avoid that duplicate navigation.
-    child->initializeAsChildFrame(frame()->host(), result.storedValue->value.get(), name, AtomicString());
+    child->initializeWebCoreFrame(frame()->host(), result.storedValue->value.get(), name, nullAtom);
     // Partially related with the above FIXME--the init() call may trigger JS dispatch. However,
     // if the parent is remote, it should never be detached synchronously...
     ASSERT(child->frame());
     return child;
 }
 
-void WebRemoteFrameImpl::initializeAsMainFrame(Page* page)
+void WebRemoteFrameImpl::initializeWebCoreFrame(FrameHost* host, FrameOwner* owner, const AtomicString& name)
 {
-    setWebCoreFrame(RemoteFrame::create(&m_frameClient, &page->frameHost(), 0));
+    setWebCoreFrame(RemoteFrame::create(&m_frameClient, host, owner));
+    m_frame->tree().setName(name, nullAtom);
 }
 
 WebRemoteFrame* WebRemoteFrameImpl::createRemoteChild(const WebString& name, WebFrameClient* client)
 {
     WebRemoteFrameImpl* child = toWebRemoteFrameImpl(WebRemoteFrame::create(client));
     HashMap<WebFrame*, OwnPtr<FrameOwner> >::AddResult result =
         m_ownersForChildren.add(child, adoptPtr(new PlaceholderFrameOwner));
     appendChild(child);
-    RefPtr<RemoteFrame> childFrame = RemoteFrame::create(&child->m_frameClient, frame()->host(), result.storedValue->value.get());
-    child->setWebCoreFrame(childFrame);
-    childFrame->tree().setName(name, AtomicString());
+    child->initializeWebCoreFrame(frame()->host(), result.storedValue->value.get(), name);
     return child;
 }
 
 void WebRemoteFrameImpl::setWebCoreFrame(PassRefPtr<RemoteFrame> frame)
 {
     m_frame = frame;
 }
 
 WebRemoteFrameImpl* WebRemoteFrameImpl::fromFrame(RemoteFrame& frame)
 {
     if (!frame.client())
         return 0;
     return static_cast<RemoteFrameClient*>(frame.client())->webFrame();
 }
 
 } // namespace blink