Plumbing for rendering stats subscriber.

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/file_path.h"
 #include "base/file_util.h"
@@ skipping 77 matching lines @@
 class GpuBenchmarkingWrapper : public v8::Extension {
  public:
   GpuBenchmarkingWrapper() :
       v8::Extension(kGpuBenchmarkingExtensionName,
           "if (typeof(chrome) == 'undefined') {"
           "  chrome = {};"
           "};"
           "if (typeof(chrome.gpuBenchmarking) == 'undefined') {"
           "  chrome.gpuBenchmarking = {};"
           "};"
+          "chrome.gpuBenchmarking.startRecordingRenderingStats = function() {"
+          "  native function StartRecordingRenderingStats();"
+          "  StartRecordingRenderingStats();"
+          "};"
+          "chrome.gpuBenchmarking.stopRecordingRenderingStats = function() {"
+          "  native function GetRenderingStats();"
+          "  return GetRenderingStats(true);"
+          "};"
           "chrome.gpuBenchmarking.renderingStats = function() {"
           "  native function GetRenderingStats();"
-          "  return GetRenderingStats();"
+          "  return GetRenderingStats(false);"
           "};"
           "chrome.gpuBenchmarking.printToSkPicture = function(dirname) {"
           "  native function PrintToSkPicture();"
           "  return PrintToSkPicture(dirname);"
           "};"
           "chrome.gpuBenchmarking.smoothScrollBy = "
           "    function(pixels_to_scroll, opt_callback, opt_mouse_event_x,"
           "             opt_mouse_event_y) {"
           "  pixels_to_scroll = pixels_to_scroll || 0;"
           "  callback = opt_callback || function() { };"
           "  native function BeginSmoothScroll();"
           "  if (typeof opt_mouse_event_x !== 'undefined' &&"
           "      typeof opt_mouse_event_y !== 'undefined') {"
           "    return BeginSmoothScroll(pixels_to_scroll >= 0, callback,"
           "                             Math.abs(pixels_to_scroll),"
           "                             opt_mouse_event_x, opt_mouse_event_y);"
           "  } else {"
           "    return BeginSmoothScroll(pixels_to_scroll >= 0, callback,"
           "                             Math.abs(pixels_to_scroll));"
           "  }"
           "};"
           "chrome.gpuBenchmarking.runRenderingBenchmarks = function(filter) {"
           "  native function RunRenderingBenchmarks();"
           "  return RunRenderingBenchmarks(filter);"
           "};") {}
 
   virtual v8::Handle<v8::FunctionTemplate> GetNativeFunction(
       v8::Handle<v8::String> name) {
+    if (name->Equals(v8::String::New("StartRecordingRenderingStats")))
+      return v8::FunctionTemplate::New(StartRecordingRenderingStats);
     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);
 
     return v8::Handle<v8::FunctionTemplate>();
   }
 
+  static v8::Handle<v8::Value> StartRecordingRenderingStats(
+      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();
+
+    render_view_impl->StartRecordingRenderingStats();
+    return v8::Undefined();
+  }
+
   static v8::Handle<v8::Value> GetRenderingStats(const v8::Arguments& args) {
 
+    if (args.Length() != 1 ||
+        !args[0]->IsBoolean())

[apatrick_chromium, 2012/11/05 20:33:18]

nit: this condition expression would fit on one line.

+      return v8::Undefined();
+
+    bool use_rendering_stats_subscriber = args[0]->BooleanValue();
+
     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();
 
     WebRenderingStats stats;
-    render_view_impl->GetRenderingStats(stats);
+    if (use_rendering_stats_subscriber)
+      render_view_impl->StopRecordingRenderingStats(stats);
+    else
+      render_view_impl->GetRenderingStats(stats);
 
     content::GpuRenderingStats gpu_stats;
     render_view_impl->GetGpuRenderingStats(&gpu_stats);
     v8::Handle<v8::Object> stats_object = v8::Object::New();
     stats_object->Set(v8::String::New("numAnimationFrames"),
                       v8::Integer::New(stats.numAnimationFrames));
     stats_object->Set(v8::String::New("numFramesSentToScreen"),
                       v8::Integer::New(stats.numFramesSentToScreen));
     stats_object->Set(v8::String::New("droppedFrameCount"),
                       v8::Integer::New(stats.droppedFrameCount));
@@ skipping 201 matching lines @@
 
     return results;
   }
 };
 
 v8::Extension* GpuBenchmarkingExtension::Get() {
   return new GpuBenchmarkingWrapper();
 }
 
 }  // namespace content