Plumbing for frame-specific WebWidgets

Source/core/rendering/compositing/RenderLayerCompositor.cpp

 /*
  * Copyright (C) 2009, 2010 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 17 matching lines @@
 #include "core/rendering/compositing/RenderLayerCompositor.h"
 
 #include "core/animation/DocumentAnimations.h"
 #include "core/dom/Fullscreen.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLIFrameElement.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/inspector/InspectorNodeIds.h"
+#include "core/loader/FrameLoaderClient.h"
 #include "core/page/Chrome.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
 #include "core/page/scrolling/ScrollingCoordinator.h"
 #include "core/paint/FramePainter.h"
 #include "core/rendering/RenderEmbeddedObject.h"
 #include "core/rendering/RenderLayerStackingNode.h"
 #include "core/rendering/RenderLayerStackingNodeIterator.h"
 #include "core/rendering/RenderPart.h"
 #include "core/rendering/RenderVideo.h"
@@ skipping 169 matching lines @@
         if (child->isLocalFrame())
             toLocalFrame(child)->contentRenderer()->compositor()->assertNoUnresolvedDirtyBits();
     }
 #endif
 }
 
 void RenderLayerCompositor::setNeedsCompositingUpdate(CompositingUpdateType updateType)
 {
     ASSERT(updateType != CompositingUpdateNone);
     m_pendingUpdateType = std::max(m_pendingUpdateType, updateType);
-    page()->animator().scheduleVisualUpdate();
+    page()->animator().scheduleVisualUpdate(m_renderView.frame());
     lifecycle().ensureStateAtMost(DocumentLifecycle::LayoutClean);
 }
 
 void RenderLayerCompositor::didLayout()
 {
     // FIXME: Technically we only need to do this when the FrameView's
     // isScrollable method would return a different value.
     m_rootShouldAlwaysCompositeDirty = true;
     enableCompositingModeIfNeeded();
 
@@ skipping 832 matching lines @@
     m_rootContentLayer = nullptr;
     m_rootTransformLayer = nullptr;
 }
 
 void RenderLayerCompositor::attachRootLayer(RootLayerAttachment attachment)
 {
     if (!m_rootContentLayer)
         return;
 
     switch (attachment) {
-        case RootLayerUnattached:
-            ASSERT_NOT_REACHED();
-            break;
-        case RootLayerAttachedViaChromeClient: {
-            LocalFrame& frame = m_renderView.frameView()->frame();
-            Page* page = frame.page();
-            if (!page)
-                return;
-            page->chrome().client().attachRootGraphicsLayer(rootGraphicsLayer());
-            break;
-        }
-        case RootLayerAttachedViaEnclosingFrame: {
-            HTMLFrameOwnerElement* ownerElement = m_renderView.document().ownerElement();
-            ASSERT(ownerElement);
-            // The layer will get hooked up via CompositedLayerMapping::updateGraphicsLayerConfiguration()
-            // for the frame's renderer in the parent document.
-            ownerElement->setNeedsCompositingUpdate();
-            break;
-        }
+    case RootLayerUnattached:
+        ASSERT_NOT_REACHED();
+        break;
+    case RootLayerAttachedViaChromeClient: {
+        LocalFrame& frame = m_renderView.frameView()->frame();
+        Page* page = frame.page();
+        if (!page)
+            return;
+        page->chrome().client().attachRootGraphicsLayer(rootGraphicsLayer(), &frame);
+        break;
+    }
+    case RootLayerAttachedViaEnclosingFrame: {
+        HTMLFrameOwnerElement* ownerElement = m_renderView.document().ownerElement();
+        ASSERT(ownerElement);
+        // The layer will get hooked up via CompositedLayerMapping::updateGraphicsLayerConfiguration()
+        // for the frame's renderer in the parent document.
+        ownerElement->setNeedsCompositingUpdate();
+        break;
+    }
     }
 
     m_rootLayerAttachment = attachment;
 }
 
 void RenderLayerCompositor::detachRootLayer()
 {
     if (!m_rootContentLayer || m_rootLayerAttachment == RootLayerUnattached)
         return;
 
     switch (m_rootLayerAttachment) {
     case RootLayerAttachedViaEnclosingFrame: {
         // The layer will get unhooked up via CompositedLayerMapping::updateGraphicsLayerConfiguration()
         // for the frame's renderer in the parent document.
         if (m_overflowControlsHostLayer)
             m_overflowControlsHostLayer->removeFromParent();
         else
             m_rootContentLayer->removeFromParent();
 
         if (HTMLFrameOwnerElement* ownerElement = m_renderView.document().ownerElement())
             ownerElement->setNeedsCompositingUpdate();
         break;
     }
     case RootLayerAttachedViaChromeClient: {
         LocalFrame& frame = m_renderView.frameView()->frame();
         Page* page = frame.page();
         if (!page)
             return;
-        page->chrome().client().attachRootGraphicsLayer(0);
+        page->chrome().client().attachRootGraphicsLayer(0, &frame);
+        break;
     }
-    break;
     case RootLayerUnattached:
         break;
     }
 
     m_rootLayerAttachment = RootLayerUnattached;
 }
 
 void RenderLayerCompositor::updateRootLayerAttachment()
 {
     ensureRootLayer();
@@ skipping 48 matching lines @@
     } else if (graphicsLayer == m_scrollLayer.get()) {
         name = "LocalFrame Scrolling Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace blink