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

Source/web/WebViewImpl.cpp

 /*
  * Copyright (C) 2011, 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 31 matching lines @@
 #include "core/editing/FrameSelection.h"
 #include "core/editing/InputMethodController.h"
 #include "core/editing/TextIterator.h"
 #include "core/events/KeyboardEvent.h"
 #include "core/events/WheelEvent.h"
 #include "core/frame/EventHandlerRegistry.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/PinchViewport.h"
+#include "core/frame/RemoteFrame.h"
 #include "core/frame/Settings.h"
 #include "core/frame/SmartClip.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/html/HTMLMediaElement.h"
 #include "core/html/HTMLPlugInElement.h"
 #include "core/html/HTMLTextAreaElement.h"
 #include "core/html/ime/InputMethodContext.h"
 #include "core/inspector/InspectorController.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/loader/FrameLoader.h"
@@ skipping 247 matching lines @@
 {
     ASSERT(pageLoadDeferrerStack().size());
 
     delete pageLoadDeferrerStack().last();
     pageLoadDeferrerStack().removeLast();
 }
 
 void WebViewImpl::setMainFrame(WebFrame* frame)
 {
     if (frame->isWebLocalFrame())
-        toWebLocalFrameImpl(frame)->initializeAsMainFrame(page());
-    else
-        toWebRemoteFrameImpl(frame)->initializeAsMainFrame(page());
+        toWebLocalFrameImpl(frame)->initializeWebCoreFrame(&page()->frameHost(), 0, nullAtom, nullAtom);
+    else {
+        m_baseBackgroundColor = Color::darkGray;
+        toWebRemoteFrameImpl(frame)->initializeWebCoreFrame(&page()->frameHost(), 0, nullAtom);
+    }
 }
 
 void WebViewImpl::setAutofillClient(WebAutofillClient* autofillClient)
 {
     m_autofillClient = autofillClient;
 }
 
 void WebViewImpl::setDevToolsAgentClient(WebDevToolsAgentClient* devToolsClient)
 {
     if (devToolsClient)
@@ skipping 107 matching lines @@
 WebViewImpl::~WebViewImpl()
 {
     ASSERT(!m_page);
 }
 
 WebLocalFrameImpl* WebViewImpl::mainFrameImpl()
 {
     return m_page && m_page->mainFrame() && m_page->mainFrame()->isLocalFrame() ? WebLocalFrameImpl::fromFrame(m_page->deprecatedLocalMainFrame()) : 0;
 }
 
+WebLocalFrameImpl* WebViewImpl::localRootFrame()
+{
+  for (WebCore::Frame* frame = page()->mainFrame()->tree().top(); frame; frame = frame->tree().traverseNext()) {
+    if (frame->isLocalRoot()) {
+      return WebLocalFrameImpl::fromFrame(toLocalFrame(frame));
+    }
+  }
+  return 0;
+}
+
 bool WebViewImpl::tabKeyCyclesThroughElements() const
 {
     ASSERT(m_page);
     return m_page->tabKeyCyclesThroughElements();
 }
 
 void WebViewImpl::setTabKeyCyclesThroughElements(bool value)
 {
     if (m_page)
         m_page->setTabKeyCyclesThroughElements(value);
@@ skipping 564 matching lines @@
         return false;
 
     if (!suppress && !handler.keyEvent(evt))
         return keyEventDefault(event);
 
     return true;
 }
 
 WebRect WebViewImpl::computeBlockBounds(const WebRect& rect, bool ignoreClipping)
 {
-    if (!mainFrameImpl())
+    if (!mainFrameImpl()) {
+        printf("WVI::computeBlockBounds: null mainFrameImpl\n");
         return WebRect();
+    }
 
     // Use the rect-based hit test to find the node.
     IntPoint point = mainFrameImpl()->frameView()->windowToContents(IntPoint(rect.x, rect.y));
     HitTestRequest::HitTestRequestType hitType = HitTestRequest::ReadOnly | HitTestRequest::Active | (ignoreClipping ? HitTestRequest::IgnoreClipping : 0);
     HitTestResult result = mainFrameImpl()->frame()->eventHandler().hitTestResultAtPoint(point, hitType, IntSize(rect.width, rect.height));
 
     Node* node = result.innerNonSharedNode();
     if (!node)
         return WebRect();
 
@@ skipping 529 matching lines @@
 void WebViewImpl::resizePinchViewport(const WebSize& newSize)
 {
     if (!pinchVirtualViewportEnabled())
         return;
 
     page()->frameHost().pinchViewport().setSize(newSize);
 }
 
 void WebViewImpl::resize(const WebSize& newSize)
 {
-    if (m_shouldAutoResize || m_size == newSize)
+    printf("WebViewImpl::resize: %dx%d\n", newSize.width, newSize.height);
+    if (m_shouldAutoResize || m_size == newSize) {
+        printf("WebViewImpl::resize: auto or same\n");
         return;
+    }
 
-    FrameView* view = mainFrameImpl()->frameView();
-    if (!view)
+    /*
+    if (!mainFrameImpl()) {
+        printf("WCI::resize: null mainFrameImpl\n");
         return;
+    }
+    */
+    WebLocalFrameImpl* mainFrameImpl = localRootFrame();
+
+    FrameView* view = mainFrameImpl->frameView();
+    if (!view) {
+        printf("WebViewImpl::resize: no view\n");
+        return;
+    }
 
     WebSize oldSize = m_size;
     float oldPageScaleFactor = pageScaleFactor();
     int oldContentsWidth = contentsSize().width();
 
     m_size = newSize;
 
     bool shouldAnchorAndRescaleViewport = settings()->mainFrameResizesAreOrientationChanges()
         && oldSize.width && oldContentsWidth && newSize.width != oldSize.width && !m_fullscreenController->isFullscreen();
 
-    ViewportAnchor viewportAnchor(&mainFrameImpl()->frame()->eventHandler());
+    ViewportAnchor viewportAnchor(&mainFrameImpl->frame()->eventHandler());
     if (shouldAnchorAndRescaleViewport) {
         viewportAnchor.setAnchor(view->visibleContentRect(),
                                  FloatSize(viewportAnchorXCoord, viewportAnchorYCoord));
     }
 
     {
         // Avoids unnecessary invalidations while various bits of state in FastTextAutosizer are updated.
-        FastTextAutosizer::DeferUpdatePageInfo deferUpdatePageInfo(page());
+        //FastTextAutosizer::DeferUpdatePageInfo deferUpdatePageInfo(page());
 
         m_pageScaleConstraintsSet.didChangeViewSize(m_size);
 
-        updatePageDefinedViewportConstraints(mainFrameImpl()->frame()->document()->viewportDescription());
+        updatePageDefinedViewportConstraints(mainFrameImpl->frame()->document()->viewportDescription());
         updateMainFrameLayoutSize();
 
         // If the virtual viewport pinch mode is enabled, the main frame will be resized
         // after layout so it can be sized to the contentsSize.
-        if (!pinchVirtualViewportEnabled() && mainFrameImpl()->frameView())
-            mainFrameImpl()->frameView()->resize(m_size);
+        if (!pinchVirtualViewportEnabled() && mainFrameImpl->frameView())
+            mainFrameImpl->frameView()->resize(m_size);
 
         if (pinchVirtualViewportEnabled())
             page()->frameHost().pinchViewport().setSize(m_size);
 
         // When device emulation is enabled, device size values may change - they are
         // usually set equal to the view size. These values are not considered viewport-dependent
         // (see MediaQueryExp::isViewportDependent), since they are only viewport-dependent in emulation mode,
         // and thus will not be invalidated in |FrameView::performPreLayoutTasks|.
         // Therefore we should force explicit media queries invalidation here.
         if (page()->inspectorController().deviceEmulationEnabled()) {
-            if (Document* document = mainFrameImpl()->frame()->document())
+            if (Document* document = mainFrameImpl->frame()->document())
                 document->mediaQueryAffectingValueChanged();
         }
     }
 
     if (settings()->viewportEnabled() && !m_fixedLayoutSizeLock) {
         // Relayout immediately to recalculate the minimum scale limit.
         if (view->needsLayout())
             view->layout();
 
         if (shouldAnchorAndRescaleViewport) {
@@ skipping 459 matching lines @@
         return false;
     *location = plainTextRange.start();
     *length = plainTextRange.length();
     return true;
 }
 
 WebTextInputInfo WebViewImpl::textInputInfo()
 {
     WebTextInputInfo info;
 
-    LocalFrame* focused = toLocalFrame(focusedWebCoreFrame());
+    Frame* focusedFrame = focusedWebCoreFrame();
+    if (focusedFrame->isRemoteFrame())
+        return info;
+
+    LocalFrame* focused = toLocalFrame(focusedFrame);
     if (!focused)
         return info;
 
     FrameSelection& selection = focused->selection();
     Node* node = selection.selection().rootEditableElement();
     if (!node)
         return info;
 
     info.inputMode = inputModeOfFocusedElement();
 
@@ skipping 105 matching lines @@
     if (isHTMLTextAreaElement(*element)) {
         const HTMLTextAreaElement& textarea = toHTMLTextAreaElement(*element);
         return textarea.fastGetAttribute(HTMLNames::inputmodeAttr).lower();
     }
 
     return WebString();
 }
 
 bool WebViewImpl::selectionBounds(WebRect& anchor, WebRect& focus) const
 {
-    const LocalFrame* frame = toLocalFrame(focusedWebCoreFrame());
+    const Frame* local_frame = focusedWebCoreFrame();
+    if (local_frame && local_frame->isRemoteFrame())
+        return false;
+
+    const LocalFrame* frame = toLocalFrame(local_frame);
     if (!frame)
         return false;
     FrameSelection& selection = frame->selection();
 
     if (selection.isCaret()) {
         anchor = focus = selection.absoluteCaretBounds();
     } else {
         RefPtrWillBeRawPtr<Range> selectedRange = selection.toNormalizedRange();
         if (!selectedRange)
             return false;
@@ skipping 268 matching lines @@
         relativeToFrame = mainFrame();
     Frame* frame = toWebLocalFrameImpl(relativeToFrame)->frame();
     frame = frame->tree().find(name);
     if (!frame || !frame->isLocalFrame())
         return 0;
     return WebLocalFrameImpl::fromFrame(toLocalFrame(frame));
 }
 
 WebFrame* WebViewImpl::focusedFrame()
 {
-    return WebLocalFrameImpl::fromFrame(toLocalFrame(focusedWebCoreFrame()));
+    Frame* frame = focusedWebCoreFrame();
+    if (frame->isRemoteFrame())
+        return WebRemoteFrameImpl::fromFrame(toRemoteFrame(*frame));
+    return WebLocalFrameImpl::fromFrame(toLocalFrame(frame));
 }
 
 void WebViewImpl::setFocusedFrame(WebFrame* frame)
 {
     if (!frame) {
         // Clears the focused frame if any.
         Frame* focusedFrame = focusedWebCoreFrame();
         if (focusedFrame && focusedFrame->isLocalFrame())
             toLocalFrame(focusedFrame)->selection().setFocused(false);
         return;
@@ skipping 327 matching lines @@
     configureAutoResizeMode();
 }
 
 void WebViewImpl::setUserAgentPageScaleConstraints(PageScaleConstraints newConstraints)
 {
     if (newConstraints == m_pageScaleConstraintsSet.userAgentConstraints())
         return;
 
     m_pageScaleConstraintsSet.setUserAgentConstraints(newConstraints);
 
-    if (!mainFrameImpl() || !mainFrameImpl()->frameView())
+    WebLocalFrameImpl* mainFrameImpl = localRootFrame();
+    if (!mainFrameImpl || !mainFrameImpl->frameView()) {
+        printf("WCI::setUserAgentPageScaleConstraints: %p\n", mainFrameImpl);
         return;
+    }
 
-    mainFrameImpl()->frameView()->setNeedsLayout();
+    mainFrameImpl->frameView()->setNeedsLayout();
 }
 
 void WebViewImpl::setInitialPageScaleOverride(float initialPageScaleFactorOverride)
 {
     PageScaleConstraints constraints = m_pageScaleConstraintsSet.userAgentConstraints();
     constraints.initialScale = initialPageScaleFactorOverride;
 
     if (constraints == m_pageScaleConstraintsSet.userAgentConstraints())
         return;
 
@@ skipping 17 matching lines @@
         constraints.maximumScale = m_pageScaleConstraintsSet.defaultConstraints().maximumScale;
     } else {
         constraints.minimumScale = -1;
         constraints.maximumScale = -1;
     }
     setUserAgentPageScaleConstraints(constraints);
 }
 
 void WebViewImpl::refreshPageScaleFactorAfterLayout()
 {
-    if (!mainFrame() || !page() || !page()->mainFrame() || !page()->mainFrame()->isLocalFrame() || !page()->deprecatedLocalMainFrame()->view())
+    /*
+    if (!mainFrame() || !page() || !page()->mainFrame() || !page()->mainFrame()->isLocalFrame() || !page()->deprecatedLocalMainFrame()->view()) {
+        printf("WebViewImpl::refreshPageScaleFactorAfterLayout: returning due to framing\n");
         return;
-    FrameView* view = page()->deprecatedLocalMainFrame()->view();
+    }
+    */
+    WebLocalFrameImpl* mainFrameImpl = localRootFrame();
+    if (!mainFrameImpl->frameView()) {
+        printf("WebViewImpl::refreshPageScaleFactorAfterLayout: returning no view\n");
+        return;
+    }
+    FrameView* view = mainFrameImpl->frameView();
 
-    updatePageDefinedViewportConstraints(mainFrameImpl()->frame()->document()->viewportDescription());
+    updatePageDefinedViewportConstraints(mainFrameImpl->frame()->document()->viewportDescription());
     m_pageScaleConstraintsSet.computeFinalConstraints();
 
     if (settings()->shrinksViewportContentToFit() && !m_fixedLayoutSizeLock) {
         int verticalScrollbarWidth = 0;
         if (view->verticalScrollbar() && !view->verticalScrollbar()->isOverlayScrollbar())
             verticalScrollbarWidth = view->verticalScrollbar()->width();
         m_pageScaleConstraintsSet.adjustFinalConstraintsToContentsSize(contentsSize(), verticalScrollbarWidth);
     }
 
     if (pinchVirtualViewportEnabled())
-        mainFrameImpl()->frameView()->resize(m_pageScaleConstraintsSet.mainFrameSize(contentsSize()));
+        mainFrameImpl->frameView()->resize(m_pageScaleConstraintsSet.mainFrameSize(contentsSize()));
 
     float newPageScaleFactor = pageScaleFactor();
     if (m_pageScaleConstraintsSet.needsReset() && m_pageScaleConstraintsSet.finalConstraints().initialScale != -1) {
         newPageScaleFactor = m_pageScaleConstraintsSet.finalConstraints().initialScale;
         m_pageScaleConstraintsSet.setNeedsReset(false);
     }
     setPageScaleFactor(newPageScaleFactor);
 
     updateLayerTreeViewport();
 
@@ skipping 63 matching lines @@
     updateMainFrameLayoutSize();
 
     if (LocalFrame* frame = page()->deprecatedLocalMainFrame()) {
         if (FastTextAutosizer* textAutosizer = frame->document()->fastTextAutosizer())
             textAutosizer->updatePageInfoInAllFrames();
     }
 }
 
 void WebViewImpl::updateMainFrameLayoutSize()
 {
-    if (m_fixedLayoutSizeLock || m_shouldAutoResize || !mainFrameImpl())
+    WebLocalFrameImpl* mainFrameImpl = localRootFrame();
+
+    if (m_fixedLayoutSizeLock || m_shouldAutoResize || !mainFrameImpl) {
+        printf("WCI::updateMainFrameLayoutSize: null mainFrameImpl\n");
         return;
+    }
 
-    RefPtr<FrameView> view = mainFrameImpl()->frameView();
+    RefPtr<FrameView> view = mainFrameImpl->frameView();
     if (!view)
         return;
 
     WebSize layoutSize = m_size;
 
     if (settings()->viewportEnabled()) {
         layoutSize = flooredIntSize(m_pageScaleConstraintsSet.pageDefinedConstraints().layoutSize);
 
         bool textAutosizingEnabled = page()->settings().textAutosizingEnabled();
         if (textAutosizingEnabled && layoutSize.width != view->layoutSize().width()) {
@@ skipping 322 matching lines @@
     if (!(dropEffect & dragData.draggingSourceOperationMask()))
         dropEffect = DragOperationNone;
 
      m_dragOperation = static_cast<WebDragOperation>(dropEffect);
 
     return m_dragOperation;
 }
 
 void WebViewImpl::sendResizeEventAndRepaint()
 {
+    WebLocalFrameImpl* mainFrameImpl = localRootFrame();
     // FIXME: This is wrong. The FrameView is responsible sending a resizeEvent
     // as part of layout. Layout is also responsible for sending invalidations
     // to the embedder. This method and all callers may be wrong. -- eseidel.
-    if (mainFrameImpl()->frameView()) {
+    if (mainFrameImpl->frameView()) {
         // Enqueues the resize event.
-        mainFrameImpl()->frame()->document()->enqueueResizeEvent();
+        mainFrameImpl->frame()->document()->enqueueResizeEvent();
     }
 
     if (m_client) {
         if (isAcceleratedCompositingActive()) {
             updateLayerTreeViewport();
         } else {
             WebRect damagedRect(0, 0, m_size.width, m_size.height);
             m_client->didInvalidateRect(damagedRect);
         }
     }
@@ skipping 231 matching lines @@
         m_pageScaleConstraintsSet.setNeedsReset(true);
 
     // Make sure link highlight from previous page is cleared.
     m_linkHighlights.clear();
     endActiveFlingAnimation();
     m_userGestureObserved = false;
 }
 
 void WebViewImpl::willInsertBody(WebLocalFrameImpl* webframe)
 {
-    if (webframe != mainFrameImpl())
+    /*
+    if (webframe != mainFrameImpl()) {
+        printf("WCI::willInsertBody: frame != mainFrameImpl\n");
         return;
+    }
 
-    if (!m_page->mainFrame()->isLocalFrame())
+    if (!m_page->mainFrame()->isLocalFrame()) {
+        printf("WCI::willInsertBody: mainFrame not local\n");
         return;
+    }
+    */
 
     // If we get to the <body> tag and we have no pending stylesheet and import load, we
     // can be fairly confident we'll have something sensible to paint soon and
     // can turn off deferred commits.
-    if (m_page->deprecatedLocalMainFrame()->document()->isRenderingReady())
+    if (webframe->frame()->document()->isRenderingReady())
         resumeTreeViewCommits();
 }
 
 void WebViewImpl::resumeTreeViewCommits()
 {
     if (m_layerTreeViewCommitsDeferred) {
         if (m_layerTreeView)
             m_layerTreeView->setDeferCommits(false);
         m_layerTreeViewCommitsDeferred = false;
     }
 }
 
 void WebViewImpl::layoutUpdated(WebLocalFrameImpl* webframe)
 {
-    if (!m_client || webframe != mainFrameImpl())
+    if (!m_client || !webframe->frame()->isLocalRoot())
         return;
 
     // If we finished a layout while in deferred commit mode,
     // that means it's time to start producing frames again so un-defer.
     resumeTreeViewCommits();
 
-    if (m_shouldAutoResize && mainFrameImpl()->frame() && mainFrameImpl()->frame()->view()) {
-        WebSize frameSize = mainFrameImpl()->frame()->view()->frameRect().size();
+    if (m_shouldAutoResize && webframe->frame() && webframe->frame()->view()) {
+        WebSize frameSize = webframe->frame()->view()->frameRect().size();
         if (frameSize != m_size) {
             m_size = frameSize;
 
             page()->frameHost().pinchViewport().setSize(m_size);
             m_pageScaleConstraintsSet.didChangeViewSize(m_size);
 
             m_client->didAutoResize(m_size);
             sendResizeEventAndRepaint();
         }
     }
@@ skipping 195 matching lines @@
         m_client->didInvalidateRect(rect);
 }
 
 WebCore::GraphicsLayerFactory* WebViewImpl::graphicsLayerFactory() const
 {
     return m_graphicsLayerFactory.get();
 }
 
 WebCore::RenderLayerCompositor* WebViewImpl::compositor() const
 {
+    for (Frame* frame = page()->mainFrame()->tree().top(); frame; frame = frame->tree().traverseNext()) {
+        if (frame->isLocalRoot())
+            return toLocalFrame(frame)->document()->renderView()->compositor();
+    }
+
     if (!page()
         || !page()->mainFrame()
         || !page()->mainFrame()->isLocalFrame()
         || !page()->deprecatedLocalMainFrame()->document()
         || !page()->deprecatedLocalMainFrame()->document()->renderView())
         return 0;
     return page()->deprecatedLocalMainFrame()->document()->renderView()->compositor();
 }
 
 void WebViewImpl::registerForAnimations(WebLayer* layer)
@@ skipping 101 matching lines @@
         return;
 
     bool oldProgrammaticScroll = frameView->inProgrammaticScroll();
     frameView->setInProgrammaticScroll(programmaticScroll);
     frameView->notifyScrollPositionChanged(scrollPosition);
     frameView->setInProgrammaticScroll(oldProgrammaticScroll);
 }
 
 void WebViewImpl::applyScrollAndScale(const WebSize& scrollDelta, float pageScaleDelta)
 {
-    if (!mainFrameImpl() || !mainFrameImpl()->frameView())
+    if (!mainFrameImpl() || !mainFrameImpl()->frameView()) {
+        printf("WCI::applyScrollAndScale: null mainFrameImpl\n");
         return;
+    }
 
     if (pinchVirtualViewportEnabled()) {
         if (pageScaleDelta != 1) {
             // When the virtual viewport is enabled, offsets are already set for us.
             setPageScaleFactor(pageScaleFactor() * pageScaleDelta);
             m_doubleTapZoomPending = false;
         }
 
         return;
     }
@@ skipping 157 matching lines @@
     const PageScaleConstraints& constraints = m_pageScaleConstraintsSet.pageDefinedConstraints();
 
     if (!mainFrameImpl() || !mainFrameImpl()->frameView())
         return false;
 
     return mainFrameImpl()->frameView()->layoutSize().width() == m_size.width
         || (constraints.minimumScale == constraints.maximumScale && constraints.minimumScale != -1);
 }
 
 } // namespace blink