Add a layer of indirection between Frame and Page

Source/core/frame/Frame.cpp

 /*
  * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
  *                     1999 Lars Knoll <knoll@kde.org>
  *                     1999 Antti Koivisto <koivisto@kde.org>
  *                     2000 Simon Hausmann <hausmann@kde.org>
  *                     2000 Stefan Schimanski <1Stein@gmx.de>
  *                     2001 George Staikos <staikos@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2005 Alexey Proskuryakov <ap@nypop.com>
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
@@ skipping 26 matching lines @@
 #include "core/editing/Editor.h"
 #include "core/editing/FrameSelection.h"
 #include "core/editing/InputMethodController.h"
 #include "core/editing/SpellChecker.h"
 #include "core/editing/htmlediting.h"
 #include "core/editing/markup.h"
 #include "core/events/Event.h"
 #include "core/fetch/ResourceFetcher.h"
 #include "core/frame/DOMWindow.h"
 #include "core/frame/FrameDestructionObserver.h"
+#include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/Settings.h"
 #include "core/frame/animation/AnimationController.h"
 #include "core/html/HTMLFrameElementBase.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/loader/EmptyClients.h"
 #include "core/loader/FrameLoaderClient.h"
 #include "core/page/Chrome.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/EventHandler.h"
@@ skipping 38 matching lines @@
 
 static inline float parentTextZoomFactor(Frame* frame)
 {
     Frame* parent = frame->tree().parent();
     if (!parent)
         return 1;
     return parent->textZoomFactor();
 }
 
 inline Frame::Frame(PassRefPtr<FrameInit> frameInit)
-    : m_page(frameInit->page())
+    : m_host(frameInit->frameHost())
     , m_treeNode(this, parentFromOwnerElement(frameInit->ownerElement()))
     , m_loader(this, frameInit->frameLoaderClient())
     , m_navigationScheduler(this)
     , m_script(adoptPtr(new ScriptController(this)))
     , m_editor(Editor::create(*this))
     , m_spellChecker(SpellChecker::create(*this))
     , m_selection(adoptPtr(new FrameSelection(this)))
     , m_eventHandler(adoptPtr(new EventHandler(this)))
     , m_animationController(adoptPtr(new AnimationController(this)))
     , m_inputMethodController(InputMethodController::create(*this))
     , m_frameInit(frameInit)
     , m_pageZoomFactor(parentPageZoomFactor(this))
     , m_textZoomFactor(parentTextZoomFactor(this))
 #if ENABLE(ORIENTATION_EVENTS)
     , m_orientation(0)
 #endif
     , m_inViewSourceMode(false)
     , m_remotePlatformLayer(0)
 {
-    ASSERT(m_page);
+    ASSERT(page());
 
     if (ownerElement()) {
-        m_page->incrementSubframeCount();
+        page()->incrementSubframeCount();
         ownerElement()->setContentFrame(*this);
     }
 
 #ifndef NDEBUG
     frameCounter.increment();
 #endif
 }
 
 PassRefPtr<Frame> Frame::create(PassRefPtr<FrameInit> frameInit)
 {
@@ skipping 61 matching lines @@
     }
 
     if (m_view)
         m_view->unscheduleRelayout();
 
     eventHandler().clear();
 
     m_view = view;
 
     if (m_view && isMainFrame())
-        m_view->setVisibleContentScaleFactor(m_page->pageScaleFactor());
+        m_view->setVisibleContentScaleFactor(page()->pageScaleFactor());
 }
 
 #if ENABLE(ORIENTATION_EVENTS)
 void Frame::sendOrientationChangeEvent(int orientation)
 {
     m_orientation = orientation;
     if (DOMWindow* window = domWindow())
         window->dispatchEvent(Event::create(EventTypeNames::orientationchange));
 }
 #endif // ENABLE(ORIENTATION_EVENTS)
 
+FrameHost* Frame::host() const
+{
+    return m_host;
+}
+
+Page* Frame::page() const
+{
+    return m_host ? &m_host->page() : nullptr;
+}
+
 Settings* Frame::settings() const
 {
-    return m_page ? &m_page->settings() : 0;
+    return m_host ? &m_host->settings() : nullptr;
 }
 
 void Frame::setPrinting(bool printing, const FloatSize& pageSize, const FloatSize& originalPageSize, float maximumShrinkRatio, AdjustViewSizeOrNot shouldAdjustViewSize)
 {
     // In setting printing, we should not validate resources already cached for the document.
     // See https://bugs.webkit.org/show_bug.cgi?id=43704
     ResourceCacheValidationSuppressor validationSuppressor(document()->fetcher());
 
     document()->setPrinting(printing);
     view()->adjustMediaTypeForPrinting(printing);
@@ skipping 89 matching lines @@
         document()->dispatchVisibilityStateChangeEvent();
 
     Vector<RefPtr<Frame> > childFrames;
     for (Frame* child = tree().firstChild(); child; child = child->tree().nextSibling())
         childFrames.append(child);
 
     for (size_t i = 0; i < childFrames.size(); ++i)
         childFrames[i]->dispatchVisibilityStateChangeEvent();
 }
 
-void Frame::willDetachPage()
+void Frame::willDetachFrameHost()
 {
     // We should never be detatching the page during a Layout.
     RELEASE_ASSERT(!m_view || !m_view->isInLayout());
 
     if (Frame* parent = tree().parent())
         parent->loader().checkLoadComplete();
 
     HashSet<FrameDestructionObserver*>::iterator stop = m_destructionObservers.end();
     for (HashSet<FrameDestructionObserver*>::iterator it = m_destructionObservers.begin(); it != stop; ++it)
-        (*it)->willDetachPage();
+        (*it)->willDetachFrameHost();
 
+    // FIXME: Page should take care of updating focus/scrolling instead of Frame.
     // FIXME: It's unclear as to why this is called more than once, but it is,
     // so page() could be NULL.
     if (page() && page()->focusController().focusedFrame() == this)
         page()->focusController().setFocusedFrame(0);
 
     if (page() && page()->scrollingCoordinator() && m_view)
         page()->scrollingCoordinator()->willDestroyScrollableArea(m_view.get());
 
     script().clearScriptObjects();
 }
 
-void Frame::detachFromPage()
+void Frame::detachFromFrameHost()
 {
     // We should never be detatching the page during a Layout.
     RELEASE_ASSERT(!m_view || !m_view->isInLayout());
-    m_page = 0;
+    m_host = 0;
 }
 
 void Frame::disconnectOwnerElement()
 {
     if (ownerElement()) {
         if (Document* doc = document())
             doc->topDocument()->clearAXObjectCache();
         ownerElement()->clearContentFrame();
-        if (m_page)
-            m_page->decrementSubframeCount();
+        if (page())
+            page()->decrementSubframeCount();
     }
     m_frameInit->setOwnerElement(0);
 }
 
 bool Frame::isMainFrame() const
 {
-    return m_page && this == m_page->mainFrame();
+    Page* page = this->page();
+    return page && this == page->mainFrame();
 }
 
 String Frame::documentTypeString() const
 {
     if (DocumentType* doctype = document()->doctype())
         return createMarkup(doctype);
 
     return String();
 }
 
@@ skipping 57 matching lines @@
     }
 
     return 0;
 }
 
 void Frame::createView(const IntSize& viewportSize, const Color& backgroundColor, bool transparent,
     ScrollbarMode horizontalScrollbarMode, bool horizontalLock,
     ScrollbarMode verticalScrollbarMode, bool verticalLock)
 {
     ASSERT(this);
-    ASSERT(m_page);
+    ASSERT(page());
 
     bool isMainFrame = this->isMainFrame();
 
     if (isMainFrame && view())
         view()->setParentVisible(false);
 
     setView(0);
 
     RefPtr<FrameView> frameView;
     if (isMainFrame) {
@@ skipping 102 matching lines @@
 {
     // Ensure that this method is being called on the main frame of the page.
     ASSERT(isMainFrame());
 
     unsigned count = 0;
     for (const Frame* frame = this; frame; frame = frame->tree().traverseNext()) {
         if (frame->document())
             count += WheelController::from(frame->document())->wheelEventHandlerCount();
     }
 
-    m_page->chrome().client().numWheelEventHandlersChanged(count);
+    m_host->chrome().client().numWheelEventHandlersChanged(count);
 }
 
 bool Frame::isURLAllowed(const KURL& url) const
 {
     // We allow one level of self-reference because some sites depend on that,
     // but we don't allow more than one.
-    if (m_page->subframeCount() >= Page::maxNumberOfFrames)
+    if (page()->subframeCount() >= Page::maxNumberOfFrames)
         return false;
     bool foundSelfReference = false;
     for (const Frame* frame = this; frame; frame = frame->tree().parent()) {
         if (equalIgnoringFragmentIdentifier(frame->document()->url(), url)) {
             if (foundSelfReference)
                 return false;
             foundSelfReference = true;
         }
     }
     return true;
@@ skipping 41 matching lines @@
     m_view->setNodeToDraw(node); // Enable special sub-tree drawing mode.
 
     // Document::updateLayout may have blown away the original RenderObject.
     RenderObject* renderer = node->renderer();
     if (!renderer)
         return nullptr;
 
     LayoutRect topLevelRect;
     IntRect paintingRect = pixelSnappedIntRect(renderer->paintingRootRect(topLevelRect));
 
-    float deviceScaleFactor = 1;
-    if (m_page)
-        deviceScaleFactor = m_page->deviceScaleFactor();
+    // If the node has a renderer, this Frame must be active and have a host.

[abarth-chromium, 2013/12/15 06:04:23]

Can we make this an ASSERT rather than a comment?  Perhaps:

ASSERT(document()->isActive()) ?

+    float deviceScaleFactor = m_host->deviceScaleFactor();
     paintingRect.setWidth(paintingRect.width() * deviceScaleFactor);
     paintingRect.setHeight(paintingRect.height() * deviceScaleFactor);
 
     OwnPtr<ImageBuffer> buffer = ImageBuffer::create(paintingRect.size());
     if (!buffer)
         return nullptr;
     buffer->context()->scale(FloatSize(deviceScaleFactor, deviceScaleFactor));
     buffer->context()->translate(-paintingRect.x(), -paintingRect.y());
     buffer->context()->clip(FloatRect(0, 0, paintingRect.maxX(), paintingRect.maxY()));
 
     m_view->paintContents(buffer->context(), paintingRect);
 
     RefPtr<Image> image = buffer->copyImage();
     return DragImage::create(image.get(), renderer->shouldRespectImageOrientation());
 }
 
 PassOwnPtr<DragImage> Frame::dragImageForSelection()
 {
     if (!selection().isRange())
         return nullptr;
 
     const ScopedFramePaintingState state(this, 0);
     m_view->setPaintBehavior(PaintBehaviorSelectionOnly | PaintBehaviorFlattenCompositingLayers);
     document()->updateLayout();
 
     IntRect paintingRect = enclosingIntRect(selection().bounds());
 
-    float deviceScaleFactor = 1;
-    if (m_page)
-        deviceScaleFactor = m_page->deviceScaleFactor();
+    // If the node has a renderer, this Frame must be active and have a host.

[abarth-chromium, 2013/12/15 06:04:23]

ditto

+    float deviceScaleFactor = m_host->deviceScaleFactor();
     paintingRect.setWidth(paintingRect.width() * deviceScaleFactor);
     paintingRect.setHeight(paintingRect.height() * deviceScaleFactor);
 
     OwnPtr<ImageBuffer> buffer = ImageBuffer::create(paintingRect.size());
     if (!buffer)
         return nullptr;
     buffer->context()->scale(FloatSize(deviceScaleFactor, deviceScaleFactor));
     buffer->context()->translate(-paintingRect.x(), -paintingRect.y());
     buffer->context()->clip(FloatRect(0, 0, paintingRect.maxX(), paintingRect.maxY()));
 
     m_view->paintContents(buffer->context(), paintingRect);
 
     RefPtr<Image> image = buffer->copyImage();
     return DragImage::create(image.get());
 }
 
 double Frame::devicePixelRatio() const
 {
-    if (!m_page)
+    if (!m_host)
         return 0;
 
-    double ratio = m_page->deviceScaleFactor();
+    double ratio = m_host->deviceScaleFactor();
     if (RuntimeEnabledFeatures::devicePixelRatioIncludesZoomEnabled())
         ratio *= pageZoomFactor();
     return ratio;
 }
 
 } // namespace WebCore