[cc] Trace detailed tile info when --trace-all-rendered-frames

content/renderer/gpu/gpu_benchmarking_extension.cc

 // Copyright (c) 2012 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 "content/renderer/gpu/gpu_benchmarking_extension.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/string_number_conversions.h"
+#include "cc/layer_tree_host.h"
 #include "content/common/gpu/gpu_rendering_stats.h"
 #include "content/public/renderer/render_thread.h"
+#include "content/public/renderer/v8_value_converter.h"
 #include "content/renderer/all_rendering_benchmarks.h"
 #include "content/renderer/render_view_impl.h"
 #include "content/renderer/rendering_benchmark.h"
 #include "third_party/skia/include/core/SkGraphics.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "third_party/skia/include/core/SkStream.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebViewBenchmarkSupport.h"
 #include "v8/include/v8.h"
+#include "webkit/compositor_bindings/web_layer_tree_view_impl.h"
 #include "webkit/compositor_bindings/web_rendering_stats_impl.h"
 
 using WebKit::WebCanvas;
 using WebKit::WebFrame;
+using WebKit::WebLayerTreeViewImpl;
 using WebKit::WebPrivatePtr;
 using WebKit::WebRenderingStatsImpl;
 using WebKit::WebSize;
 using WebKit::WebView;
 using WebKit::WebViewBenchmarkSupport;
 
 const char kGpuBenchmarkingExtensionName[] = "v8/GpuBenchmarking";
 
 namespace {
 
@@ skipping 107 matching lines @@
           "                             Math.abs(pixels_to_scroll));"
           "  }"
           "};"
           "chrome.gpuBenchmarking.runRenderingBenchmarks = function(filter) {"
           "  native function RunRenderingBenchmarks();"
           "  return RunRenderingBenchmarks(filter);"
           "};"
           "chrome.gpuBenchmarking.beginWindowSnapshotPNG = function(callback) {"
           "  native function BeginWindowSnapshotPNG();"
           "  BeginWindowSnapshotPNG(callback);"
+          "};"
+          "chrome.gpuBenchmarking.layerTreeAsValue = function() {"
+          "  native function LayerTreeAsValue();"
+          "  LayerTreeAsValue();"
           "};") {}
 
   virtual v8::Handle<v8::FunctionTemplate> GetNativeFunction(
       v8::Handle<v8::String> name) {
     if (name->Equals(v8::String::New("GetRenderingStats")))
       return v8::FunctionTemplate::New(GetRenderingStats);
     if (name->Equals(v8::String::New("PrintToSkPicture")))
       return v8::FunctionTemplate::New(PrintToSkPicture);
     if (name->Equals(v8::String::New("BeginSmoothScroll")))
       return v8::FunctionTemplate::New(BeginSmoothScroll);
     if (name->Equals(v8::String::New("RunRenderingBenchmarks")))
       return v8::FunctionTemplate::New(RunRenderingBenchmarks);
     if (name->Equals(v8::String::New("BeginWindowSnapshotPNG")))
       return v8::FunctionTemplate::New(BeginWindowSnapshotPNG);
+    if (name->Equals(v8::String::New("LayerTreeAsValue")))
+      return v8::FunctionTemplate::New(LayerTreeAsValue);
 
     return v8::Handle<v8::FunctionTemplate>();
   }
 
   static v8::Handle<v8::Value> GetRenderingStats(const v8::Arguments& args) {
 
     WebFrame* web_frame = WebFrame::frameForCurrentContext();
     if (!web_frame)
       return v8::Undefined();
 
@@ skipping 255 matching lines @@
     v8::Persistent<v8::Function> callback =
         v8::Persistent<v8::Function>::New(callback_local);
     v8::Persistent<v8::Context> context =
         v8::Persistent<v8::Context>::New(web_frame->mainWorldScriptContext());
 
     render_view_impl->GetWindowSnapshot(
         base::Bind(&OnSnapshotCompleted, callback, context));
 
     return v8::Undefined();
   }
+
+  static v8::Handle<v8::Value> LayerTreeAsValue(
+      const v8::Arguments& args) {
+    WebFrame* web_frame = WebFrame::frameForCurrentContext();
+    if (!web_frame)
+      return v8::Undefined();
+
+    WebView* web_view = web_frame->view();
+    if (!web_view)
+      return v8::Undefined();
+
+    RenderViewImpl* render_view_impl = RenderViewImpl::FromWebView(web_view);
+    if (!render_view_impl)
+      return v8::Undefined();
+
+    WebLayerTreeViewImpl* layer_tree_view_impl =
+        static_cast<WebLayerTreeViewImpl*>(render_view_impl->layerTreeView());

[piman, 2013/02/12 04:55:07]

This is a content::RenderWidgetCompositor now... Might be worth adding an
accessor on RenderWidget so that we can use it without casting (protecting
ourselves against possible breakage - if this had landed before James's CL, we'd
have had an ugly boom.)

+
+    if (!layer_tree_view_impl)
+      return v8::Undefined();
+
+    cc::LayerTreeHost* cc_layer_tree_host =
+      layer_tree_view_impl->layer_tree_host();
+    if (!cc_layer_tree_host)
+      return v8::Undefined();
+
+    scoped_ptr<base::Value> value = cc_layer_tree_host->asValue();
+    scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
+    v8::Persistent<v8::Context> context =
+        v8::Persistent<v8::Context>::New(web_frame->mainWorldScriptContext());
+    return converter->ToV8Value(value.get(), context);
+  }
 };
 
 v8::Extension* GpuBenchmarkingExtension::Get() {
   return new GpuBenchmarkingWrapper();
 }
 
 }  // namespace content