Add testRunner.capturePixelsThen() method

content/shell/renderer/test_runner/test_runner.cc

 // Copyright 2014 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/shell/renderer/test_runner/test_runner.h"
 
 #include <limits>
 
 #include "base/logging.h"
 #include "content/shell/common/test_runner/test_preferences.h"
 #include "content/shell/renderer/test_runner/MockWebSpeechRecognizer.h"
 #include "content/shell/renderer/test_runner/TestInterfaces.h"
 #include "content/shell/renderer/test_runner/WebPermissions.h"
 #include "content/shell/renderer/test_runner/WebTestDelegate.h"
 #include "content/shell/renderer/test_runner/mock_web_push_client.h"
 #include "content/shell/renderer/test_runner/notification_presenter.h"
 #include "content/shell/renderer/test_runner/web_test_proxy.h"
 #include "gin/arguments.h"
 #include "gin/array_buffer.h"
 #include "gin/handle.h"
 #include "gin/object_template_builder.h"
 #include "gin/wrappable.h"
+#include "third_party/WebKit/public/platform/WebArrayBuffer.h"
 #include "third_party/WebKit/public/platform/WebBatteryStatus.h"
 #include "third_party/WebKit/public/platform/WebCanvas.h"
 #include "third_party/WebKit/public/platform/WebData.h"
 #include "third_party/WebKit/public/platform/WebDeviceMotionData.h"
 #include "third_party/WebKit/public/platform/WebDeviceOrientationData.h"
 #include "third_party/WebKit/public/platform/WebPoint.h"
 #include "third_party/WebKit/public/platform/WebURLResponse.h"
+#include "third_party/WebKit/public/web/WebArrayBufferConverter.h"
 #include "third_party/WebKit/public/web/WebBindings.h"
 #include "third_party/WebKit/public/web/WebDataSource.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFindOptions.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebInputElement.h"
 #include "third_party/WebKit/public/web/WebKit.h"
 #include "third_party/WebKit/public/web/WebMIDIClientMock.h"
 #include "third_party/WebKit/public/web/WebPageOverlay.h"
 #include "third_party/WebKit/public/web/WebScriptSource.h"
 #include "third_party/WebKit/public/web/WebSecurityPolicy.h"
 #include "third_party/WebKit/public/web/WebSerializedScriptValue.h"
 #include "third_party/WebKit/public/web/WebSettings.h"
 #include "third_party/WebKit/public/web/WebSurroundingText.h"
 #include "third_party/WebKit/public/web/WebView.h"
+#include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 
 #if defined(__linux__) || defined(ANDROID)
 #include "third_party/WebKit/public/web/linux/WebFontRendering.h"
 #endif
 
 using namespace blink;
 
 namespace content {
 
@@ skipping 19 matching lines @@
  private:
   CallbackMethodType callback_;
 };
 
 }  // namespace
 
 class InvokeCallbackTask : public WebMethodTask<TestRunner> {
  public:
   InvokeCallbackTask(TestRunner* object, v8::Handle<v8::Function> callback)
       : WebMethodTask<TestRunner>(object),
-        callback_(blink::mainThreadIsolate(), callback) {}
+        callback_(blink::mainThreadIsolate(), callback),
+        argc_(0) {}
 
   virtual void runIfValid() OVERRIDE {
     v8::Isolate* isolate = blink::mainThreadIsolate();
     v8::HandleScope handle_scope(isolate);
     WebFrame* frame = m_object->web_view_->mainFrame();
 
     v8::Handle<v8::Context> context = frame->mainWorldScriptContext();
     if (context.IsEmpty())
       return;
 
     v8::Context::Scope context_scope(context);
 
+    scoped_ptr<v8::Handle<v8::Value>[]> local_argv;
+    if (argc_) {
+        local_argv.reset(new v8::Handle<v8::Value>[argc_]);
+        for (int i = 0; i < argc_; ++i)
+          local_argv[i] = v8::Local<v8::Value>::New(isolate, argv_[i]);
+    }
+
     frame->callFunctionEvenIfScriptDisabled(
         v8::Local<v8::Function>::New(isolate, callback_),
         context->Global(),
-        0,
-        NULL);
+        argc_,
+        local_argv.get());
+  }
+
+  void SetArguments(int argc, v8::Handle<v8::Value> argv[]) {
+    v8::Isolate* isolate = blink::mainThreadIsolate();
+    argc_ = argc;
+    argv_.reset(new v8::UniquePersistent<v8::Value>[argc]);
+    for (int i = 0; i < argc; ++i)
+      argv_[i] = v8::UniquePersistent<v8::Value>(isolate, argv[i]);
   }
 
  private:
   v8::UniquePersistent<v8::Function> callback_;
+  int argc_;
+  scoped_ptr<v8::UniquePersistent<v8::Value>[]> argv_;
 };
 
 class TestRunnerBindings : public gin::Wrappable<TestRunnerBindings> {
  public:
   static gin::WrapperInfo kWrapperInfo;
 
   static void Install(base::WeakPtr<TestRunner> controller,
                       WebFrame* frame);
 
  private:
@@ skipping 133 matching lines @@
   bool SimulateWebNotificationClick(const std::string& value);
   void AddMockSpeechRecognitionResult(const std::string& transcript,
                                       double confidence);
   void SetMockSpeechRecognitionError(const std::string& error,
                                      const std::string& message);
   bool WasMockSpeechRecognitionAborted();
   void AddWebPageOverlay();
   void RemoveWebPageOverlay();
   void DisplayAsync();
   void DisplayAsyncThen(v8::Handle<v8::Function> callback);
+  void CapturePixelsAsyncThen(v8::Handle<v8::Function> callback);
   void SetCustomTextOutput(std::string output);
   void SetViewSourceForFrame(const std::string& name, bool enabled);
   void setMockPushClientSuccess(const std::string& end_point,
                                 const std::string& registration_id);
   void setMockPushClientError(const std::string& message);
 
   bool GlobalFlag();
   void SetGlobalFlag(bool value);
   std::string PlatformName();
   std::string TooltipText();
@@ skipping 224 matching lines @@
                  &TestRunnerBindings::AddMockSpeechRecognitionResult)
       .SetMethod("setMockSpeechRecognitionError",
                  &TestRunnerBindings::SetMockSpeechRecognitionError)
       .SetMethod("wasMockSpeechRecognitionAborted",
                  &TestRunnerBindings::WasMockSpeechRecognitionAborted)
       .SetMethod("addWebPageOverlay", &TestRunnerBindings::AddWebPageOverlay)
       .SetMethod("removeWebPageOverlay",
                  &TestRunnerBindings::RemoveWebPageOverlay)
       .SetMethod("displayAsync", &TestRunnerBindings::DisplayAsync)
       .SetMethod("displayAsyncThen", &TestRunnerBindings::DisplayAsyncThen)
+      .SetMethod("capturePixelsAsyncThen", &TestRunnerBindings::CapturePixelsAsyncThen)
       .SetMethod("setCustomTextOutput",
                  &TestRunnerBindings::SetCustomTextOutput)
       .SetMethod("setViewSourceForFrame",
                  &TestRunnerBindings::SetViewSourceForFrame)
       .SetMethod("setMockPushClientSuccess",
                  &TestRunnerBindings::setMockPushClientSuccess)
       .SetMethod("setMockPushClientError",
                  &TestRunnerBindings::setMockPushClientError)
 
       // Properties.
@@ skipping 780 matching lines @@
 void TestRunnerBindings::DisplayAsync() {
   if (runner_)
     runner_->DisplayAsync();
 }
 
 void TestRunnerBindings::DisplayAsyncThen(v8::Handle<v8::Function> callback) {
   if (runner_)
     runner_->DisplayAsyncThen(callback);
 }
 
+void TestRunnerBindings::CapturePixelsAsyncThen(
+    v8::Handle<v8::Function> callback) {
+  if (runner_)
+    runner_->CapturePixelsAsyncThen(callback);
+}
+
 void TestRunnerBindings::SetCustomTextOutput(std::string output) {
   runner_->setCustomTextOutput(output);
 }
 
 void TestRunnerBindings::SetViewSourceForFrame(const std::string& name,
                                                bool enabled) {
   if (runner_ && runner_->web_view_) {
     WebFrame* target_frame =
         runner_->web_view_->findFrameByName(WebString::fromUTF8(name));
     if (target_frame)
@@ skipping 1397 matching lines @@
 }
 
 void TestRunner::DisplayAsyncThen(v8::Handle<v8::Function> callback) {
   scoped_ptr<InvokeCallbackTask> task(
       new InvokeCallbackTask(this, callback));
   proxy_->DisplayAsyncThen(base::Bind(&TestRunner::InvokeCallback,
                                       base::Unretained(this),
                                       base::Passed(&task)));
 }
 
+void TestRunner::CapturePixelsAsyncThen(v8::Handle<v8::Function> callback) {
+  scoped_ptr<InvokeCallbackTask> task(
+      new InvokeCallbackTask(this, callback));
+  proxy_->CapturePixelsAsync(base::Bind(&TestRunner::CapturePixelsCallback,
+                                        base::Unretained(this),
+                                        base::Passed(&task)));
+}
+
+void TestRunner::CapturePixelsCallback(scoped_ptr<InvokeCallbackTask> task,
+                                       const SkBitmap& snapshot) {
+  v8::Isolate* isolate = blink::mainThreadIsolate();
+  v8::HandleScope handle_scope(isolate);
+
+  v8::Handle<v8::Context> context =
+      web_view_->mainFrame()->mainWorldScriptContext();
+  if (context.IsEmpty())
+    return;
+
+  v8::Context::Scope context_scope(context);
+  v8::Handle<v8::Value> argv[3];
+  SkAutoLockPixels snapshot_lock(snapshot);
+
+  int width = snapshot.info().fWidth;
+  DCHECK_NE(0, width);
+  argv[0] = v8::Number::New(isolate, width);
+
+  int height = snapshot.info().fHeight;
+  DCHECK_NE(0, height);
+  argv[1] = v8::Number::New(isolate, height);
+
+  blink::WebArrayBuffer buffer =
+      blink::WebArrayBuffer::create(snapshot.getSize(), 1);
+  memcpy(buffer.data(), snapshot.getPixels(), buffer.byteLength());
+  argv[2] = blink::WebArrayBufferConverter::toV8Value(
+      &buffer, context->Global(), isolate);
+
+  task->SetArguments(3, argv);
+  InvokeCallback(task.Pass());
+}
+
 void TestRunner::SetMockPushClientSuccess(
   const std::string& end_point, const std::string& registration_id) {
   proxy_->GetPushClientMock()->SetMockSuccessValues(end_point, registration_id);
 }
 
 void TestRunner::SetMockPushClientError(const std::string& message) {
   proxy_->GetPushClientMock()->SetMockErrorValues(message);
 }
 
 void TestRunner::LocationChangeDone() {
@@ skipping 43 matching lines @@
 }
 
 void TestRunner::DidLosePointerLockInternal() {
   bool was_locked = pointer_locked_;
   pointer_locked_ = false;
   if (was_locked)
     web_view_->didLosePointerLock();
 }
 
 }  // namespace content