Moving pixel-capturing code from web_test_proxy_base.* into pixel_dump.*

components/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 "components/test_runner/test_runner.h"
 
 #include <stddef.h>
 #include <limits>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
 #include "components/test_runner/app_banner_client.h"
 #include "components/test_runner/layout_dump.h"
 #include "components/test_runner/mock_credential_manager_client.h"
 #include "components/test_runner/mock_screen_orientation_client.h"
 #include "components/test_runner/mock_web_speech_recognizer.h"
 #include "components/test_runner/mock_web_user_media_client.h"
+#include "components/test_runner/pixel_dump.h"
 #include "components/test_runner/test_interfaces.h"
 #include "components/test_runner/test_preferences.h"
 #include "components/test_runner/web_content_settings.h"
 #include "components/test_runner/web_test_delegate.h"
 #include "components/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"
@@ skipping 1667 matching lines @@
 #endif
     web_view_->setVisibilityState(WebPageVisibilityStateVisible, true);
     web_view_->mainFrame()->enableViewSourceMode(false);
 
     web_view_->setPageOverlayColor(SK_ColorTRANSPARENT);
   }
 
   top_loading_frame_ = nullptr;
   layout_test_runtime_flags_.Reset();
   mock_screen_orientation_client_->ResetData();
+  drag_image_.reset();
   wait_until_external_url_load_ = false;
 
   WebSecurityPolicy::resetOriginAccessWhitelists();
 #if defined(__linux__) || defined(ANDROID)
   WebFontRendering::setSubpixelPositioning(false);
 #endif
 
   if (delegate_) {
     // Reset the default quota for each origin to 5MB
     delegate_->SetDatabaseQuota(5 * 1024 * 1024);
@@ skipping 18 matching lines @@
   dump_user_gesture_in_frame_load_callbacks_ = false;
   dump_title_changes_ = false;
   dump_create_view_ = false;
   can_open_windows_ = false;
   dump_resource_load_callbacks_ = false;
   dump_resource_request_callbacks_ = false;
   dump_resource_response_mime_types_ = false;
   dump_window_status_changes_ = false;
   dump_spell_check_callbacks_ = false;
   dump_back_forward_list_ = false;
-  dump_selection_rect_ = false;
-  dump_drag_image_ = false;
   dump_navigation_policy_ = false;
   test_repaint_ = false;
   sweep_horizontally_ = false;
   midi_accessor_result_ = true;
   should_stay_on_page_after_handling_before_unload_ = false;
   should_dump_resource_priorities_ = false;
   has_custom_text_output_ = false;
   custom_text_output_.clear();
 
   http_headers_to_clear_.clear();
@@ skipping 80 matching lines @@
 bool TestRunner::IsRecursiveLayoutDumpRequested() {
   CheckResponseMimeType();
   return layout_test_runtime_flags_.dump_child_frames();
 }
 
 std::string TestRunner::DumpLayout(blink::WebLocalFrame* frame) {
   CheckResponseMimeType();
   return ::test_runner::DumpLayout(frame, layout_test_runtime_flags_);
 }
 
+void TestRunner::DumpPixelsAsync(
+    blink::WebView* web_view,
+    const base::Callback<void(const SkBitmap&)>& callback) {
+  if (layout_test_runtime_flags_.dump_drag_image()) {
+    if (drag_image_.isNull()) {
+      // This means the test called dumpDragImage but did not initiate a drag.
+      // Return a blank image so that the test fails.
+      SkBitmap bitmap;
+      bitmap.allocN32Pixels(1, 1);
+      {
+        SkAutoLockPixels lock(bitmap);
+        bitmap.eraseColor(0);
+      }
+      callback.Run(bitmap);
+      return;
+    }
+
+    callback.Run(drag_image_.getSkBitmap());
+    return;
+  }
+
+  test_runner::DumpPixelsAsync(proxy_->GetWebView(), layout_test_runtime_flags_,
+                               delegate_->GetDeviceScaleFactorForTest(),
+                               callback);
+}
+
 void TestRunner::ReplicateLayoutTestRuntimeFlagsChanges(
     const base::DictionaryValue& changed_values) {
   layout_test_runtime_flags_.tracked_dictionary().ApplyUntrackedChanges(
       changed_values);
 }
 
 bool TestRunner::HasCustomTextDump(std::string* custom_text_dump) const {
   if (shouldDumpAsCustomText()) {
     *custom_text_dump = customDumpText();
     return true;
@@ skipping 63 matching lines @@
 }
 
 bool TestRunner::shouldDumpSpellCheckCallbacks() const {
   return dump_spell_check_callbacks_;
 }
 
 bool TestRunner::ShouldDumpBackForwardList() const {
   return dump_back_forward_list_;
 }
 
-bool TestRunner::shouldDumpSelectionRect() const {
-  return dump_selection_rect_;
-}
-
 bool TestRunner::isPrinting() const {
   return layout_test_runtime_flags_.is_printing();
 }
 
 bool TestRunner::shouldWaitUntilExternalURLLoad() const {
   return wait_until_external_url_load_;
 }
 
 const std::set<std::string>* TestRunner::httpHeadersToClear() const {
   return &http_headers_to_clear_;
@@ skipping 68 matching lines @@
 }
 
 bool TestRunner::isPointerLocked() {
   return pointer_locked_;
 }
 
 void TestRunner::setToolTipText(const WebString& text) {
   tooltip_text_ = text.utf8();
 }
 
-bool TestRunner::shouldDumpDragImage() {
-  return dump_drag_image_;
+void TestRunner::setDragImage(
+    const blink::WebImage& drag_image) {
+  if (layout_test_runtime_flags_.dump_drag_image()) {
+    if (drag_image_.isNull())
+      drag_image_ = drag_image;
+  }
 }
 
 bool TestRunner::shouldDumpNavigationPolicy() const {
   return dump_navigation_policy_;
 }
 
 bool TestRunner::midiAccessorResult() {
   return midi_accessor_result_;
 }
 
@@ skipping 763 matching lines @@
 
 void TestRunner::DumpSpellCheckCallbacks() {
   dump_spell_check_callbacks_ = true;
 }
 
 void TestRunner::DumpBackForwardList() {
   dump_back_forward_list_ = true;
 }
 
 void TestRunner::DumpSelectionRect() {
-  dump_selection_rect_ = true;
+  layout_test_runtime_flags_.set_dump_selection_rect(true);
+  OnLayoutTestRuntimeFlagsChanged();
 }
 
 void TestRunner::SetPrinting() {
   layout_test_runtime_flags_.set_is_printing(true);
   OnLayoutTestRuntimeFlagsChanged();
 }
 
 void TestRunner::ClearPrinting() {
   layout_test_runtime_flags_.set_is_printing(false);
   OnLayoutTestRuntimeFlagsChanged();
@@ skipping 20 matching lines @@
 void TestRunner::ShowWebInspector(const std::string& str,
                                   const std::string& frontend_url) {
   ShowDevTools(str, frontend_url);
 }
 
 void TestRunner::WaitUntilExternalURLLoad() {
   wait_until_external_url_load_ = true;
 }
 
 void TestRunner::DumpDragImage() {
+  layout_test_runtime_flags_.set_dump_drag_image(true);
   DumpAsTextWithPixelResults();
-  dump_drag_image_ = true;
+  OnLayoutTestRuntimeFlagsChanged();
 }
 
 void TestRunner::DumpNavigationPolicy() {
   dump_navigation_policy_ = true;
 }
 
 void TestRunner::DumpPageImportanceSignals() {
   blink::WebPageImportanceSignals* signals =
     web_view_->pageImportanceSignals();
   if (!signals)
@@ skipping 198 matching lines @@
   scoped_ptr<InvokeCallbackTask> task(
       new InvokeCallbackTask(this, callback));
 
   delegate_->FetchManifest(
       web_view_, web_view_->mainFrame()->document().manifestURL(),
       base::Bind(&TestRunner::GetManifestCallback, weak_factory_.GetWeakPtr(),
                  base::Passed(&task)));
 }
 
 void TestRunner::CapturePixelsAsyncThen(v8::Local<v8::Function> callback) {
-  scoped_ptr<InvokeCallbackTask> task(
-      new InvokeCallbackTask(this, callback));
-  proxy_->CapturePixelsAsync(base::Bind(&TestRunner::CapturePixelsCallback,
-                                        weak_factory_.GetWeakPtr(),
-                                        base::Passed(&task)));
+  scoped_ptr<InvokeCallbackTask> task(new InvokeCallbackTask(this, callback));
+  DumpPixelsAsync(proxy_->GetWebView(),
+                  base::Bind(&TestRunner::CapturePixelsCallback,
+                             weak_factory_.GetWeakPtr(), base::Passed(&task)));
 }
 
 void TestRunner::OnLayoutTestRuntimeFlagsChanged() {
   if (layout_test_runtime_flags_.tracked_dictionary().changed_values().empty())
     return;
 
   delegate_->OnLayoutTestRuntimeFlagsChanged(
       layout_test_runtime_flags_.tracked_dictionary().changed_values());
   layout_test_runtime_flags_.tracked_dictionary().ResetChangeTracking();
 }
 
 void TestRunner::ForceNextWebGLContextCreationToFail() {
   if (web_view_)
     web_view_->forceNextWebGLContextCreationToFail();
 }
 
 void TestRunner::ForceNextDrawingBufferCreationToFail() {
   if (web_view_)
     web_view_->forceNextDrawingBufferCreationToFail();
 }
 
 void TestRunner::CopyImageAtAndCapturePixelsAsyncThen(
     int x, int y, v8::Local<v8::Function> callback) {
   scoped_ptr<InvokeCallbackTask> task(
       new InvokeCallbackTask(this, callback));
-  proxy_->CopyImageAtAndCapturePixels(
-      x, y, base::Bind(&TestRunner::CapturePixelsCallback,
-                       weak_factory_.GetWeakPtr(),
-                       base::Passed(&task)));
+  CopyImageAtAndCapturePixels(
+      proxy_->GetWebView(), x, y,
+      base::Bind(&TestRunner::CapturePixelsCallback, weak_factory_.GetWeakPtr(),
+                 base::Passed(&task)));
 }
 
 void TestRunner::GetManifestCallback(scoped_ptr<InvokeCallbackTask> task,
                                      const blink::WebURLResponse& response,
                                      const std::string& data) {
   InvokeCallback(std::move(task));
 }
 
 void TestRunner::CapturePixelsCallback(scoped_ptr<InvokeCallbackTask> task,
                                        const SkBitmap& snapshot) {
@@ skipping 136 matching lines @@
 }
 
 void TestRunner::DidLosePointerLockInternal() {
   bool was_locked = pointer_locked_;
   pointer_locked_ = false;
   if (was_locked)
     web_view_->didLosePointerLock();
 }
 
 }  // namespace test_runner