Expose a gpu-benchmark-only measureRecordTime API to JS. This function measures the time it takes t…

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 "content/renderer/render_view_impl.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/Platform/chromium/public/WebRenderingStats.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/WebFrame.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebViewBenchmarkSupport.h"
 #include "v8/include/v8.h"
 
 using WebKit::WebFrame;
 using WebKit::WebRenderingStats;
 using WebKit::WebView;
 
 const char kGpuBenchmarkingExtensionName[] = "v8/GpuBenchmarking";
 
+using WebKit::WebCanvas;
 using WebKit::WebFrame;
+using WebKit::WebSize;
 using WebKit::WebView;
+using WebKit::WebViewBenchmarkSupport;
+
+namespace {
+class SkPictureRecordingController :
+    public WebViewBenchmarkSupport::PaintingController
+{
+public:
+  SkPictureRecordingController(SkPicture* picture) : picture_(picture) { }
+
+  // WebViewBenchmarkSupport::PaintingController overrides.
+  virtual WebCanvas* createCanvas(const WebSize& size) {
+    return picture_->beginRecording(size.width, size.height);
+  }
+  virtual void paintingComplete(const WebCanvas&) {
+    picture_->endRecording();
+  }
+
+private:
+  SkPicture* picture_;
+};
+}  // namespace
 
 namespace content {
 
 class GpuBenchmarkingWrapper : public v8::Extension {
  public:
   GpuBenchmarkingWrapper() :
       v8::Extension(kGpuBenchmarkingExtensionName,
           "if (typeof(chrome) == 'undefined') {"
           "  chrome = {};"
           "};"
           "if (typeof(chrome.gpuBenchmarking) == 'undefined') {"
           "  chrome.gpuBenchmarking = {};"
           "};"
           "chrome.gpuBenchmarking.renderingStats = function() {"
           "  native function GetRenderingStats();"
           "  return GetRenderingStats();"
           "};"
+          "chrome.gpuBenchmarking.printToSkPicture = function(filename) {"
+          "  native function PrintToSkPicture();"
+          "  return PrintToSkPicture(filename);"
+          "};"
           "chrome.gpuBenchmarking.beginSmoothScrollDown = "
           "    function(scroll_far) {"
           "  scroll_far = scroll_far || false;"
           "  native function BeginSmoothScroll();"
           "  return BeginSmoothScroll(true, scroll_far);"
           "};"
           "chrome.gpuBenchmarking.beginSmoothScrollUp = function(scroll_far) {"
           "  scroll_far = scroll_far || false;"
           "  native function BeginSmoothScroll();"
           "  return BeginSmoothScroll(false, scroll_far);"
           "};") {}
 
   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);
 
     return v8::Handle<v8::FunctionTemplate>();
   }
 
   static v8::Handle<v8::Value> GetRenderingStats(const v8::Arguments& args) {
     WebFrame* web_frame = WebFrame::frameForEnteredContext();
     if (!web_frame)
       return v8::Undefined();
@@ skipping 10 matching lines @@
       stats_object->Set(v8::String::New("numAnimationFrames"),
                         v8::Integer::New(stats.numAnimationFrames),
                         v8::ReadOnly);
     if (stats.numFramesSentToScreen)
       stats_object->Set(v8::String::New("numFramesSentToScreen"),
                         v8::Integer::New(stats.numFramesSentToScreen),
                         v8::ReadOnly);
     return stats_object;
   }
 
+  static v8::Handle<v8::Value> PrintToSkPicture(const v8::Arguments& args) {
+    if (args.Length() != 1)
+      return v8::Undefined();
+
+    v8::String::AsciiValue filename(args[0]);
+    if (filename.length() == 0)
+      return v8::Undefined();
+
+    WebFrame* web_frame = WebFrame::frameForEnteredContext();
+    if (!web_frame)
+      return v8::Undefined();
+
+    WebView* web_view = web_frame->view();
+    if (!web_view)
+      return v8::Undefined();
+
+    WebViewBenchmarkSupport* benchmark_support = web_view->benchmarkSupport();
+    if (!benchmark_support)
+      return v8::Undefined();
+
+    SkPicture picture;
+    SkPictureRecordingController controller(&picture);
+    double record_time = benchmark_support->paint(
+        controller,
+        WebViewBenchmarkSupport::PaintModeEverything);
+
+    // Open the file into which recorded SkPicture will be dumped.
+    // Note that for this to work Chrome needs to be launched with
+    // --no-sandbox command-line flag.
+    SkFILEWStream file(*filename);
+    picture.serialize(&file);
+    return v8::Number::New(record_time);
+  }
+
   static v8::Handle<v8::Value> BeginSmoothScroll(const v8::Arguments& args) {
     WebFrame* web_frame = WebFrame::frameForEnteredContext();
     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();
 
     if (args.Length() != 2 || !args[0]->IsBoolean() || !args[1]->IsBoolean())
       return v8::False();
 
     bool scroll_down = args[0]->BooleanValue();
     bool scroll_far = args[1]->BooleanValue();
 
     render_view_impl->BeginSmoothScroll(scroll_down, scroll_far);
     return v8::True();
   }
 };
 
 v8::Extension* GpuBenchmarkingExtension::Get() {
   return new GpuBenchmarkingWrapper();

[alokp, 2012/07/17 17:06:56]

does this get deleted somewhere?

 }
 
 }  // namespace content