Move LayoutAndPaintAsyncThen to a separate compilation unit.

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_and_paint_async_then.h"
 #include "components/test_runner/layout_dump.h"
 #include "components/test_runner/mock_content_settings_client.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/spell_check_client.h"
 #include "components/test_runner/test_interfaces.h"
 #include "components/test_runner/test_preferences.h"
@@ skipping 1562 matching lines @@
 }
 
 void TestRunner::SetDelegate(WebTestDelegate* delegate) {
   delegate_ = delegate;
   mock_content_settings_client_->SetDelegate(delegate);
   spellcheck_->SetDelegate(delegate);
   if (speech_recognizer_)
     speech_recognizer_->SetDelegate(delegate);
 }
 
-void TestRunner::SetWebView(WebView* webView, WebTestProxyBase* proxy) {
+void TestRunner::SetWebView(WebView* webView) {
   web_view_ = webView;
-  proxy_ = proxy;
 }
 
 void TestRunner::Reset() {
   if (web_view_) {
     web_view_->setZoomLevel(0);
     web_view_->setTextZoomFactor(1);
     web_view_->setTabKeyCyclesThroughElements(true);
 #if !defined(OS_MACOSX) && !defined(OS_WIN)
     // (Constants copied because we can't depend on the header that defined
     // them from this file.)
@@ skipping 225 matching lines @@
         bitmap.eraseColor(0);
       }
       callback.Run(bitmap);
       return;
     }
 
     callback.Run(drag_image_.getSkBitmap());
     return;
   }
 
-  test_runner::DumpPixelsAsync(proxy_->web_view(), layout_test_runtime_flags_,
+  test_runner::DumpPixelsAsync(web_view_, layout_test_runtime_flags_,
                                delegate_->GetDeviceScaleFactorForTest(),
                                callback);
 }
 
 void TestRunner::ReplicateLayoutTestRuntimeFlagsChanges(
     const base::DictionaryValue& changed_values) {
   layout_test_runtime_flags_.tracked_dictionary().ApplyUntrackedChanges(
       changed_values);
 }
 
@@ skipping 766 matching lines @@
 std::string TestRunner::GetAcceptLanguages() const {
   return layout_test_runtime_flags_.accept_languages();
 }
 
 void TestRunner::SetAcceptLanguages(const std::string& accept_languages) {
   if (accept_languages == GetAcceptLanguages())
     return;
 
   layout_test_runtime_flags_.set_accept_languages(accept_languages);
   OnLayoutTestRuntimeFlagsChanged();
-  proxy_->web_view()->acceptLanguagesChanged();
+  web_view_->acceptLanguagesChanged();
 }
 
 void TestRunner::SetPluginsEnabled(bool enabled) {
   delegate_->Preferences()->plugins_enabled = enabled;
   delegate_->ApplyPreferences();
 }
 
 bool TestRunner::GetAnimationScheduled() const {
   bool is_animation_scheduled = !views_with_scheduled_animations_.empty();
   return is_animation_scheduled;
@@ skipping 232 matching lines @@
 
 void TestRunner::SetDatabaseQuota(int quota) {
   delegate_->SetDatabaseQuota(quota);
 }
 
 void TestRunner::SetAlwaysAcceptCookies(bool accept) {
   delegate_->SetAcceptAllCookies(accept);
 }
 
 void TestRunner::SetWindowIsKey(bool value) {
-  SetFocus(proxy_->web_view(), value);
+  SetFocus(web_view_, value);
 }
 
 void TestRunner::SetFocus(blink::WebView* web_view, bool focus) {
   if (focus) {
     if (previously_focused_view_ != web_view) {
       delegate_->SetFocus(previously_focused_view_, false);
       delegate_->SetFocus(web_view, true);
       previously_focused_view_ = web_view;
     }
   } else {
@@ skipping 140 matching lines @@
   if (web_view_)
     web_view_->setPageOverlayColor(SK_ColorCYAN);
 }
 
 void TestRunner::RemoveWebPageOverlay() {
   if (web_view_)
     web_view_->setPageOverlayColor(SK_ColorTRANSPARENT);
 }
 
 void TestRunner::LayoutAndPaintAsync() {
-  proxy_->LayoutAndPaintAsyncThen(base::Closure());
+  test_runner::LayoutAndPaintAsyncThen(web_view_, base::Closure());
 }
 
 void TestRunner::LayoutAndPaintAsyncThen(v8::Local<v8::Function> callback) {
-  proxy_->LayoutAndPaintAsyncThen(CreateClosureThatPostsV8Callback(callback));
+  test_runner::LayoutAndPaintAsyncThen(
+      web_view_, CreateClosureThatPostsV8Callback(callback));
 }
 
 void TestRunner::GetManifestThen(v8::Local<v8::Function> callback) {
   v8::UniquePersistent<v8::Function> persistent_callback(
       blink::mainThreadIsolate(), callback);
 
   if (!web_view_) {
     WebURLResponse response;
     response.setHTTPStatusCode(404);
     GetManifestCallback(std::move(persistent_callback), response, "");
     return;
   }
 
   delegate_->FetchManifest(
       web_view_, web_view_->mainFrame()->document().manifestURL(),
       base::Bind(&TestRunner::GetManifestCallback, weak_factory_.GetWeakPtr(),
                  base::Passed(std::move(persistent_callback))));
 }
 
 void TestRunner::CapturePixelsAsyncThen(v8::Local<v8::Function> callback) {
   v8::UniquePersistent<v8::Function> persistent_callback(
       blink::mainThreadIsolate(), callback);
 
   if (!web_view_) {
     CapturePixelsCallback(std::move(persistent_callback), SkBitmap());
     return;
   }
 
   DumpPixelsAsync(
-      proxy_->web_view(),
+      web_view_,
       base::Bind(&TestRunner::CapturePixelsCallback, weak_factory_.GetWeakPtr(),
                  base::Passed(std::move(persistent_callback))));
 }
 
 void TestRunner::OnLayoutTestRuntimeFlagsChanged() {
   if (layout_test_runtime_flags_.tracked_dictionary().changed_values().empty())
     return;
 
   delegate_->OnLayoutTestRuntimeFlagsChanged(
       layout_test_runtime_flags_.tracked_dictionary().changed_values());
@@ skipping 14 matching lines @@
     int x, int y, v8::Local<v8::Function> callback) {
   v8::UniquePersistent<v8::Function> persistent_callback(
       blink::mainThreadIsolate(), callback);
 
   if (!web_view_) {
     CapturePixelsCallback(std::move(persistent_callback), SkBitmap());
     return;
   }
 
   CopyImageAtAndCapturePixels(
-      proxy_->web_view(), x, y,
+      web_view_, x, y,
       base::Bind(&TestRunner::CapturePixelsCallback, weak_factory_.GetWeakPtr(),
                  base::Passed(std::move(persistent_callback))));
 }
 
 void TestRunner::GetManifestCallback(
     v8::UniquePersistent<v8::Function> callback,
     const blink::WebURLResponse& response,
     const std::string& data) {
   PostV8CallbackWithArgs(std::move(callback), 0, nullptr);
 }
@@ skipping 146 matching lines @@
 }
 
 void TestRunner::DidLosePointerLockInternal() {
   bool was_locked = pointer_locked_;
   pointer_locked_ = false;
   if (was_locked)
     web_view_->didLosePointerLock();
 }
 
 }  // namespace test_runner