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);
+  }

[nduca, 2012/07/18 06:17:47]

do we use the OVERRIDE convention yet in chromium? I think we might...

[alokp, 2012/07/18 16:00:49]

Will check.

+  virtual void paintingComplete(const WebCanvas&) {
+    picture_->endRecording();
+  }
+
+ private:
+  SkPicture* picture_;
+};

[nduca, 2012/07/18 06:17:47]

Is this the right way to handle layers? You're going to end up with one giant
picture with TONS of layers in them...

[alokp, 2012/07/18 16:00:49]

We can do it in any number of ways:
1. multiple layers in one picture (current approach)
2. one picture per layer. all pictures saved into one composite picture.
3. one picture per layer. all pictures saved into separate files.

We can start with this approach to be adjusted later as needed.

+}  // 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);

[nduca, 2012/07/18 06:17:47]

We definitely want to file a bug with skia to allow serialization to memory
instead of a file. We'll need this for your  "phase 2" patch.

[alokp, 2012/07/18 16:00:49]

They already have this feature. We should sync up on "phase 2".

+    picture.serialize(&file);
+    return v8::Number::New(record_time);

[nduca, 2012/07/18 06:17:47]

Any reason we need to even return this variable? Seems we could just return
undefined and that'd be ok.

[alokp, 2012/07/18 16:00:49]

The same reason WebViewBenchmarkSupport::paint() returns paint time. It might be
useful in certain situations. But we can also remove it for now and add it later
if needed. Your call.

+  }
+
   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();
 }
 
 }  // namespace content