Extract WebViewClient implementation out of WebTestProxyBase.

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>
 
@@ skipping 1077 matching lines @@
   runner_->SetAcceptLanguages(accept_languages);
 }
 
 void TestRunnerBindings::SetPluginsEnabled(bool enabled) {
   if (runner_)
     runner_->SetPluginsEnabled(enabled);
 }
 
 bool TestRunnerBindings::AnimationScheduled() {
   if (runner_)
-    return runner_->AnimationScheduled();
+    return runner_->GetAnimationScheduled();
   else
     return false;
 }
 
 void TestRunnerBindings::DumpEditingCallbacks() {
   if (runner_)
     runner_->DumpEditingCallbacks();
 }
 
 void TestRunnerBindings::DumpAsMarkup() {
@@ skipping 567 matching lines @@
 
 TestRunner::~TestRunner() {}
 
 void TestRunner::Install(WebFrame* frame) {
   TestRunnerBindings::Install(weak_factory_.GetWeakPtr(), frame);
 }
 
 void TestRunner::SetDelegate(WebTestDelegate* delegate) {
   delegate_ = delegate;
   web_content_settings_->SetDelegate(delegate);
+  if (speech_recognizer_)
+    speech_recognizer_->SetDelegate(delegate);
 }
 
 void TestRunner::SetWebView(WebView* webView, WebTestProxyBase* proxy) {
   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.)
     web_view_->setSelectionColors(
         0xff1e90ff, 0xff000000, 0xffc8c8c8, 0xff323232);
 #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();
+  views_with_scheduled_animations_.clear();
   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 139 matching lines @@
         bitmap.eraseColor(0);
       }
       callback.Run(bitmap);
       return;
     }
 
     callback.Run(drag_image_.getSkBitmap());
     return;
   }
 
-  test_runner::DumpPixelsAsync(proxy_->GetWebView(), layout_test_runtime_flags_,
+  test_runner::DumpPixelsAsync(proxy_->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 663 matching lines @@
 MockScreenOrientationClient* TestRunner::getMockScreenOrientationClient() {
   return mock_screen_orientation_client_.get();
 }
 
 MockWebUserMediaClient* TestRunner::getMockWebUserMediaClient() {
   if (!user_media_client_.get())
     user_media_client_.reset(new MockWebUserMediaClient(delegate_));
   return user_media_client_.get();
 }
 
+MockWebSpeechRecognizer* TestRunner::getMockWebSpeechRecognizer() {
+  if (!speech_recognizer_.get()) {
+    speech_recognizer_.reset(new MockWebSpeechRecognizer());
+    speech_recognizer_->SetDelegate(delegate_);
+  }
+  return speech_recognizer_.get();
+}
+
 void TestRunner::SetMockScreenOrientation(const std::string& orientation_str) {
   blink::WebScreenOrientationType orientation;
 
   if (orientation_str == "portrait-primary") {
     orientation = WebScreenOrientationPortraitPrimary;
   } else if (orientation_str == "portrait-secondary") {
     orientation = WebScreenOrientationPortraitSecondary;
   } else if (orientation_str == "landscape-primary") {
     orientation = WebScreenOrientationLandscapePrimary;
   } else {
@@ skipping 120 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_->GetWebView()->acceptLanguagesChanged();
+  proxy_->web_view()->acceptLanguagesChanged();
 }
 
 void TestRunner::SetPluginsEnabled(bool enabled) {
   delegate_->Preferences()->plugins_enabled = enabled;
   delegate_->ApplyPreferences();
 }
 
-bool TestRunner::AnimationScheduled() {
-  return proxy_->AnimationScheduled();
+bool TestRunner::GetAnimationScheduled() const {
+  bool is_animation_scheduled = !views_with_scheduled_animations_.empty();
+  return is_animation_scheduled;
+}
+
+void TestRunner::OnAnimationScheduled(blink::WebView* view) {
+  views_with_scheduled_animations_.insert(view);
+}
+
+void TestRunner::OnAnimationBegun(blink::WebView* view) {
+  views_with_scheduled_animations_.erase(view);
 }
 
 void TestRunner::DumpEditingCallbacks() {
   dump_editting_callbacks_ = true;
 }
 
 void TestRunner::DumpAsMarkup() {
   layout_test_runtime_flags_.set_dump_as_markup(true);
   layout_test_runtime_flags_.set_generate_pixel_results(false);
   OnLayoutTestRuntimeFlagsChanged();
@@ skipping 209 matching lines @@
 
 void TestRunner::SetDatabaseQuota(int quota) {
   delegate_->SetDatabaseQuota(quota);
 }
 
 void TestRunner::SetAlwaysAcceptCookies(bool accept) {
   delegate_->SetAcceptAllCookies(accept);
 }
 
 void TestRunner::SetWindowIsKey(bool value) {
-  delegate_->SetFocus(proxy_, value);
+  delegate_->SetFocus(proxy_->web_view(), value);
 }
 
 std::string TestRunner::PathToLocalResource(const std::string& path) {
   return delegate_->PathToLocalResource(path);
 }
 
 void TestRunner::SetBackingScaleFactor(double value,
                                        v8::Local<v8::Function> callback) {
   delegate_->SetDeviceScaleFactor(value);
   delegate_->PostTask(new InvokeCallbackTask(this, callback));
@@ skipping 87 matching lines @@
   delegate_->SimulateWebNotificationClick(title, action_index);
 }
 
 void TestRunner::SimulateWebNotificationClose(const std::string& title,
                                               bool by_user) {
   delegate_->SimulateWebNotificationClose(title, by_user);
 }
 
 void TestRunner::AddMockSpeechRecognitionResult(const std::string& transcript,
                                                 double confidence) {
-  proxy_->GetSpeechRecognizerMock()->AddMockResult(
-      WebString::fromUTF8(transcript), confidence);
+  getMockWebSpeechRecognizer()->AddMockResult(WebString::fromUTF8(transcript),
+                                              confidence);
 }
 
 void TestRunner::SetMockSpeechRecognitionError(const std::string& error,
                                                const std::string& message) {
-  proxy_->GetSpeechRecognizerMock()->SetError(WebString::fromUTF8(error),
-                                              WebString::fromUTF8(message));
+  getMockWebSpeechRecognizer()->SetError(WebString::fromUTF8(error),
+                                         WebString::fromUTF8(message));
 }
 
 bool TestRunner::WasMockSpeechRecognitionAborted() {
-  return proxy_->GetSpeechRecognizerMock()->WasAborted();
+  return getMockWebSpeechRecognizer()->WasAborted();
 }
 
 void TestRunner::AddMockCredentialManagerResponse(const std::string& id,
                                                   const std::string& name,
                                                   const std::string& avatar,
                                                   const std::string& password) {
   proxy_->GetCredentialManagerClientMock()->SetResponse(
       new WebPasswordCredential(WebString::fromUTF8(id),
                                 WebString::fromUTF8(password),
                                 WebString::fromUTF8(name),
@@ skipping 31 matching lines @@
       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));
-  DumpPixelsAsync(proxy_->GetWebView(),
+  DumpPixelsAsync(proxy_->web_view(),
                   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));
   CopyImageAtAndCapturePixels(
-      proxy_->GetWebView(), x, y,
+      proxy_->web_view(), 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));
 }
 
@@ skipping 138 matching lines @@
 }
 
 void TestRunner::DidLosePointerLockInternal() {
   bool was_locked = pointer_locked_;
   pointer_locked_ = false;
   if (was_locked)
     web_view_->didLosePointerLock();
 }
 
 }  // namespace test_runner