Add a completion callback to gpuBenchmarking.beginSmoothScroll

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 117 matching lines @@
           "};"
           "chrome.gpuBenchmarking.renderingStats = function() {"
           "  native function GetRenderingStats();"
           "  return GetRenderingStats();"
           "};"
           "chrome.gpuBenchmarking.printToSkPicture = function(dirname) {"
           "  native function PrintToSkPicture();"
           "  return PrintToSkPicture(dirname);"
           "};"
           "chrome.gpuBenchmarking.beginSmoothScrollDown = "
-          "    function(scroll_far) {"
+          "    function(scroll_far, opt_callback) {"
           "  scroll_far = scroll_far || false;"
+          "  callback = opt_callback || function() { };"
           "  native function BeginSmoothScroll();"
-          "  return BeginSmoothScroll(true, scroll_far);"
+          "  return BeginSmoothScroll(true, scroll_far, callback);"
           "};"
-          "chrome.gpuBenchmarking.beginSmoothScrollUp = function(scroll_far) {"
+          "chrome.gpuBenchmarking.beginSmoothScrollUp = "
+          "    function(scroll_far, opt_callback) {"
           "  scroll_far = scroll_far || false;"
+          "  callback = opt_callback || function() { };"
           "  native function BeginSmoothScroll();"
-          "  return BeginSmoothScroll(false, scroll_far);"
+          "  return BeginSmoothScroll(false, scroll_far, callback);"
           "};"
           "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("GetRenderingStats")))
       return v8::FunctionTemplate::New(GetRenderingStats);
@@ skipping 66 matching lines @@
       return v8::ThrowException(v8::Exception::Error(
           v8::String::New(msg.c_str(), msg.length())));
     }
 
     SkPictureRecorder recorder(dirpath);
     benchmark_support->paint(&recorder,
                              WebViewBenchmarkSupport::PaintModeEverything);
     return v8::Undefined();
   }
 
+  static void OnSmoothScrollCompleted(v8::Persistent<v8::Function> callback,
+                                      v8::Persistent<v8::Context> context) {
+    v8::HandleScope scope;
+    v8::Context::Scope context_scope(context);
+    WebFrame* frame = WebFrame::frameForContext(context);
+    if (frame) {
+      frame->callFunctionEvenIfScriptDisabled(callback,
+                                              v8::Object::New(),
+                                              0,
+                                              NULL);
+    }
+    callback.Dispose();
+    context.Dispose();
+  }
+
   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())
+    if (args.Length() != 3 ||
+        !args[0]->IsBoolean() ||
+        !args[1]->IsBoolean() ||
+        !args[2]->IsFunction())
       return v8::False();
 
     bool scroll_down = args[0]->BooleanValue();
     bool scroll_far = args[1]->BooleanValue();
+    v8::Local<v8::Function> callback_local =
+        v8::Local<v8::Function>(v8::Function::Cast(*args[2]));
+    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->BeginSmoothScroll(scroll_down, scroll_far);
+    // TODO(nduca): If the render_view_impl is destroyed while the gesture is in
+    // progress, we will leak the callback and context. This needs to be fixed,
+    // somehow.
+    render_view_impl->BeginSmoothScroll(
+        scroll_down,
+        scroll_far,
+        base::Bind(&OnSmoothScrollCompleted,
+                   callback,
+                   context));
+
     return v8::True();
   }
 
   static v8::Handle<v8::Value> RunRenderingBenchmarks(
       const v8::Arguments& args) {
     // For our name filter, the argument can be undefined or null to run
     // all benchmarks, or a string for filtering by name.
     if (!args.Length() ||
         (!args[0]->IsString() &&
          !(args[0]->IsNull() || args[0]->IsUndefined()))) {
@@ skipping 39 matching lines @@
 
     return results.results_array();
   }
 };
 
 v8::Extension* GpuBenchmarkingExtension::Get() {
   return new GpuBenchmarkingWrapper();
 }
 
 }  // namespace content