Fixing crashes in layout tests when virtual-viewport is enabled.

Source/core/inspector/InspectorLayerTreeAgent.cpp

 /*
  * Copyright (C) 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2013 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.
@@ skipping 16 matching lines @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 
 #include "core/inspector/InspectorLayerTreeAgent.h"
 
 #include "core/dom/Document.h"
+#include "core/frame/FrameHost.h"
 #include "core/frame/LocalFrame.h"
+#include "core/frame/Settings.h"
 #include "core/inspector/IdentifiersFactory.h"
 #include "core/inspector/InspectorNodeIds.h"
 #include "core/inspector/InspectorState.h"
 #include "core/inspector/InstrumentingAgents.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/page/Page.h"
 #include "core/rendering/RenderPart.h"
 #include "core/rendering/RenderView.h"
 #include "core/rendering/compositing/CompositedLayerMapping.h"
 #include "core/rendering/compositing/RenderLayerCompositor.h"
@@ skipping 166 matching lines @@
 
 PassRefPtr<TypeBuilder::Array<TypeBuilder::LayerTree::Layer> > InspectorLayerTreeAgent::buildLayerTree()
 {
     RenderLayerCompositor* compositor = renderLayerCompositor();
     if (!compositor || !compositor->inCompositingMode())
         return nullptr;
 
     LayerIdToNodeIdMap layerIdToNodeIdMap;
     RefPtr<TypeBuilder::Array<TypeBuilder::LayerTree::Layer> > layers = TypeBuilder::Array<TypeBuilder::LayerTree::Layer>::create();
     buildLayerIdToNodeIdMap(compositor->rootRenderLayer(), layerIdToNodeIdMap);
-    gatherGraphicsLayers(compositor->rootGraphicsLayer(), layerIdToNodeIdMap, layers);
+    gatherGraphicsLayers(rootGraphicsLayer(), layerIdToNodeIdMap, layers);
     return layers.release();
 }
 
 void InspectorLayerTreeAgent::buildLayerIdToNodeIdMap(RenderLayer* root, LayerIdToNodeIdMap& layerIdToNodeIdMap)
 {
     if (root->hasCompositedLayerMapping()) {
         if (Node* node = root->renderer()->generatingNode()) {
             GraphicsLayer* graphicsLayer = root->compositedLayerMapping()->childForSuperlayers();
             layerIdToNodeIdMap.set(graphicsLayer->platformLayer()->id(), idForNode(node));
         }
@@ skipping 26 matching lines @@
     return InspectorNodeIds::idForNode(node);
 }
 
 RenderLayerCompositor* InspectorLayerTreeAgent::renderLayerCompositor()
 {
     RenderView* renderView = m_page->deprecatedLocalMainFrame()->contentRenderer();
     RenderLayerCompositor* compositor = renderView ? renderView->compositor() : 0;
     return compositor;
 }
 
+GraphicsLayer* InspectorLayerTreeAgent::rootGraphicsLayer()
+{
+    if (m_page->settings().pinchVirtualViewportEnabled())
+        return m_page->frameHost().pinchViewport().rootGraphicsLayer();
+
+    return renderLayerCompositor()->rootGraphicsLayer();
+}
+
 static GraphicsLayer* findLayerById(GraphicsLayer* root, int layerId)
 {
     if (root->platformLayer()->id() == layerId)
         return root;
     if (root->replicaLayer()) {
         if (GraphicsLayer* layer = findLayerById(root->replicaLayer(), layerId))
             return layer;
     }
     for (size_t i = 0, size = root->children().size(); i < size; ++i) {
         if (GraphicsLayer* layer = findLayerById(root->children()[i], layerId))
             return layer;
     }
     return 0;
 }
 
 GraphicsLayer* InspectorLayerTreeAgent::layerById(ErrorString* errorString, const String& layerId)
 {
     bool ok;
     int id = layerId.toInt(&ok);
     if (!ok) {
         *errorString = "Invalid layer id";
         return 0;
     }
     RenderLayerCompositor* compositor = renderLayerCompositor();
     if (!compositor) {
         *errorString = "Not in compositing mode";
         return 0;
     }
 
-    GraphicsLayer* result = findLayerById(compositor->rootGraphicsLayer(), id);
+    GraphicsLayer* result = findLayerById(rootGraphicsLayer(), id);
     if (!result)
         *errorString = "No layer matching given id found";
     return result;
 }
 
 void InspectorLayerTreeAgent::compositingReasons(ErrorString* errorString, const String& layerId, RefPtr<TypeBuilder::Array<String> >& reasonStrings)
 {
     const GraphicsLayer* graphicsLayer = layerById(errorString, layerId);
     if (!graphicsLayer)
         return;
@@ skipping 112 matching lines @@
 void InspectorLayerTreeAgent::didRemovePageOverlay(const GraphicsLayer* layer)
 {
     size_t index = m_pageOverlayLayerIds.find(layer->platformLayer()->id());
     if (index == WTF::kNotFound)
         return;
     m_pageOverlayLayerIds.remove(index);
 }
 
 
 } // namespace blink