Abstract class WebTestDelegate to chromium c++ style.

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/binding_helpers.h"
-#include "content/shell/renderer/test_runner/WebTestDelegate.h"
 #include "content/shell/renderer/test_runner/mock_credential_manager_client.h"
 #include "content/shell/renderer/test_runner/mock_web_push_client.h"
 #include "content/shell/renderer/test_runner/mock_web_speech_recognizer.h"
 #include "content/shell/renderer/test_runner/notification_presenter.h"
 #include "content/shell/renderer/test_runner/test_interfaces.h"
 #include "content/shell/renderer/test_runner/web_permissions.h"
+#include "content/shell/renderer/test_runner/web_test_delegate.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"
@@ skipping 1434 matching lines @@
 TestRunner::WorkQueue::~WorkQueue() {
   Reset();
 }
 
 void TestRunner::WorkQueue::ProcessWorkSoon() {
   if (controller_->topLoadingFrame())
     return;
 
   if (!queue_.empty()) {
     // We delay processing queued work to avoid recursion problems.
-    controller_->delegate_->postTask(new WorkQueueTask(this));
+    controller_->delegate_->PostTask(new WorkQueueTask(this));
   } else if (!controller_->wait_until_done_) {
-    controller_->delegate_->testFinished();
+    controller_->delegate_->TestFinished();
   }
 }
 
 void TestRunner::WorkQueue::Reset() {
   frozen_ = false;
   while (!queue_.empty()) {
     delete queue_.front();
     queue_.pop_front();
   }
 }
@@ skipping 11 matching lines @@
   while (!queue_.empty()) {
     bool startedLoad = queue_.front()->Run(controller_->delegate_,
                                            controller_->web_view_);
     delete queue_.front();
     queue_.pop_front();
     if (startedLoad)
       return;
   }
 
   if (!controller_->wait_until_done_ && !controller_->topLoadingFrame())
-    controller_->delegate_->testFinished();
+    controller_->delegate_->TestFinished();
 }
 
 void TestRunner::WorkQueue::WorkQueueTask::RunIfValid() {
   object_->ProcessWork();
 }
 
 TestRunner::TestRunner(TestInterfaces* interfaces)
     : test_is_running_(false),
       close_remaining_windows_(false),
       work_queue_(this),
@@ skipping 54 matching lines @@
   policy_delegate_is_permissive_ = false;
   policy_delegate_should_notify_done_ = 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);
-    delegate_->setDeviceColorProfile("reset");
-    delegate_->setDeviceScaleFactor(1);
-    delegate_->setAcceptAllCookies(false);
-    delegate_->setLocale("");
-    delegate_->useUnfortunateSynchronousResizeMode(false);
-    delegate_->disableAutoResizeMode(WebSize());
-    delegate_->deleteAllCookies();
-    delegate_->resetScreenOrientation();
+    delegate_->SetDatabaseQuota(5 * 1024 * 1024);
+    delegate_->SetDeviceColorProfile("reset");
+    delegate_->SetDeviceScaleFactor(1);
+    delegate_->SetAcceptAllCookies(false);
+    delegate_->SetLocale("");
+    delegate_->UseUnfortunateSynchronousResizeMode(false);
+    delegate_->DisableAutoResizeMode(WebSize());
+    delegate_->DeleteAllCookies();
+    delegate_->ResetScreenOrientation();
     ResetBatteryStatus();
     ResetDeviceLight();
   }
 
   dump_editting_callbacks_ = false;
   dump_as_text_ = false;
   dump_as_markup_ = false;
   generate_pixel_results_ = true;
   dump_child_frame_scroll_positions_ = false;
   dump_child_frames_as_markup_ = false;
@@ skipping 35 matching lines @@
 
   notification_presenter_->Reset();
   use_mock_theme_ = true;
   pointer_locked_ = false;
   pointer_lock_planned_result_ = PointerLockWillSucceed;
 
   task_list_.RevokeAll();
   work_queue_.Reset();
 
   if (close_remaining_windows_ && delegate_)
-    delegate_->closeRemainingWindows();
+    delegate_->CloseRemainingWindows();
   else
     close_remaining_windows_ = true;
 }
 
 void TestRunner::SetTestIsRunning(bool running) {
   test_is_running_ = running;
 }
 
 void TestRunner::InvokeCallback(scoped_ptr<InvokeCallbackTask> task) {
-  delegate_->postTask(task.release());
+  delegate_->PostTask(task.release());
 }
 
 bool TestRunner::shouldDumpEditingCallbacks() const {
   return dump_editting_callbacks_;
 }
 
 bool TestRunner::shouldDumpAsText() {
   CheckResponseMimeType();
   return dump_as_text_;
 }
@@ skipping 156 matching lines @@
     top_loading_frame_ = frame;
   }
 }
 
 WebFrame* TestRunner::topLoadingFrame() const {
   return top_loading_frame_;
 }
 
 void TestRunner::policyDelegateDone() {
   DCHECK(wait_until_done_);
-  delegate_->testFinished();
+  delegate_->TestFinished();
   wait_until_done_ = false;
 }
 
 bool TestRunner::policyDelegateEnabled() const {
   return policy_delegate_enabled_;
 }
 
 bool TestRunner::policyDelegateIsPermissive() const {
   return policy_delegate_is_permissive_;
 }
@@ skipping 10 matching lines @@
   return should_dump_resource_priorities_;
 }
 
 WebNotificationPresenter* TestRunner::notification_presenter() const {
   return notification_presenter_.get();
 }
 
 bool TestRunner::RequestPointerLock() {
   switch (pointer_lock_planned_result_) {
     case PointerLockWillSucceed:
-      delegate_->postDelayedTask(
+      delegate_->PostDelayedTask(
           new HostMethodTask(this, &TestRunner::DidAcquirePointerLockInternal),
           0);
       return true;
     case PointerLockWillRespondAsync:
       DCHECK(!pointer_locked_);
       return true;
     case PointerLockWillFailSync:
       DCHECK(!pointer_locked_);
       return false;
     default:
       NOTREACHED();
       return false;
   }
 }
 
 void TestRunner::RequestPointerUnlock() {
-  delegate_->postDelayedTask(
+  delegate_->PostDelayedTask(
       new HostMethodTask(this, &TestRunner::DidLosePointerLockInternal), 0);
 }
 
 bool TestRunner::isPointerLocked() {
   return pointer_locked_;
 }
 
 void TestRunner::setToolTipText(const WebString& text) {
   tooltip_text_ = text.utf8();
 }
 
 bool TestRunner::midiAccessorResult() {
   return midi_accessor_result_;
 }
 
-void TestRunner::clearDevToolsLocalStorage() {
-  delegate_->clearDevToolsLocalStorage();
+void TestRunner::ClearDevToolsLocalStorage() {
+  delegate_->ClearDevToolsLocalStorage();
 }
 
-void TestRunner::showDevTools(const std::string& settings,
+void TestRunner::ShowDevTools(const std::string& settings,
                               const std::string& frontend_url) {
-  delegate_->showDevTools(settings, frontend_url);
+  delegate_->ShowDevTools(settings, frontend_url);
 }
 
 class WorkItemBackForward : public TestRunner::WorkItem {
  public:
   WorkItemBackForward(int distance) : distance_(distance) {}
 
   virtual bool Run(WebTestDelegate* delegate, WebView*) OVERRIDE {
-    delegate->goToOffset(distance_);
+    delegate->GoToOffset(distance_);
     return true; // FIXME: Did it really start a navigation?
   }
 
  private:
   int distance_;
 };
 
 void TestRunner::NotifyDone() {
   if (disable_notify_done_)
     return;
@@ skipping 12 matching lines @@
   work_queue_.AddWork(new WorkItemBackForward(-how_far_back));
 }
 
 void TestRunner::QueueForwardNavigation(int how_far_forward) {
   work_queue_.AddWork(new WorkItemBackForward(how_far_forward));
 }
 
 class WorkItemReload : public TestRunner::WorkItem {
  public:
   virtual bool Run(WebTestDelegate* delegate, WebView*) OVERRIDE {
-    delegate->reload();
+    delegate->Reload();
     return true;
   }
 };
 
 void TestRunner::QueueReload() {
   work_queue_.AddWork(new WorkItemReload());
 }
 
 class WorkItemLoadingScript : public TestRunner::WorkItem {
  public:
@@ skipping 32 matching lines @@
 void TestRunner::QueueNonLoadingScript(const std::string& script) {
   work_queue_.AddWork(new WorkItemNonLoadingScript(script));
 }
 
 class WorkItemLoad : public TestRunner::WorkItem {
  public:
   WorkItemLoad(const WebURL& url, const std::string& target)
       : url_(url), target_(target) {}
 
   virtual bool Run(WebTestDelegate* delegate, WebView*) OVERRIDE {
-    delegate->loadURLForFrame(url_, target_);
+    delegate->LoadURLForFrame(url_, target_);
     return true; // FIXME: Did it really start a navigation?
   }
 
  private:
   WebURL url_;
   std::string target_;
 };
 
 void TestRunner::QueueLoad(const std::string& url, const std::string& target) {
   // FIXME: Implement WebURL::resolve() and avoid GURL.
@@ skipping 260 matching lines @@
     direction = WebTextDirectionRightToLeft;
   else if (direction_name == "ltr")
     direction = WebTextDirectionLeftToRight;
   else
     return;
 
   web_view_->setTextDirection(direction);
 }
 
 void TestRunner::UseUnfortunateSynchronousResizeMode() {
-  delegate_->useUnfortunateSynchronousResizeMode(true);
+  delegate_->UseUnfortunateSynchronousResizeMode(true);
 }
 
 bool TestRunner::EnableAutoResizeMode(int min_width,
                                       int min_height,
                                       int max_width,
                                       int max_height) {
   WebSize min_size(min_width, min_height);
   WebSize max_size(max_width, max_height);
-  delegate_->enableAutoResizeMode(min_size, max_size);
+  delegate_->EnableAutoResizeMode(min_size, max_size);
   return true;
 }
 
 bool TestRunner::DisableAutoResizeMode(int new_width, int new_height) {
   WebSize new_size(new_width, new_height);
-  delegate_->disableAutoResizeMode(new_size);
+  delegate_->DisableAutoResizeMode(new_size);
   return true;
 }
 
 void TestRunner::SetMockDeviceLight(double value) {
-  delegate_->setDeviceLightData(value);
+  delegate_->SetDeviceLightData(value);
 }
 
 void TestRunner::ResetDeviceLight() {
-  delegate_->setDeviceLightData(-1);
+  delegate_->SetDeviceLightData(-1);
 }
 
 void TestRunner::SetMockDeviceMotion(
     bool has_acceleration_x, double acceleration_x,
     bool has_acceleration_y, double acceleration_y,
     bool has_acceleration_z, double acceleration_z,
     bool has_acceleration_including_gravity_x,
     double acceleration_including_gravity_x,
     bool has_acceleration_including_gravity_y,
     double acceleration_including_gravity_y,
@@ skipping 28 matching lines @@
   motion.hasRotationRateAlpha = has_rotation_rate_alpha;
   motion.rotationRateAlpha = rotation_rate_alpha;
   motion.hasRotationRateBeta = has_rotation_rate_beta;
   motion.rotationRateBeta = rotation_rate_beta;
   motion.hasRotationRateGamma = has_rotation_rate_gamma;
   motion.rotationRateGamma = rotation_rate_gamma;
 
   // interval
   motion.interval = interval;
 
-  delegate_->setDeviceMotionData(motion);
+  delegate_->SetDeviceMotionData(motion);
 }
 
 void TestRunner::SetMockDeviceOrientation(bool has_alpha, double alpha,
                                           bool has_beta, double beta,
                                           bool has_gamma, double gamma,
                                           bool has_absolute, bool absolute) {
   WebDeviceOrientationData orientation;
 
   // alpha
   orientation.hasAlpha = has_alpha;
   orientation.alpha = alpha;
 
   // beta
   orientation.hasBeta = has_beta;
   orientation.beta = beta;
 
   // gamma
   orientation.hasGamma = has_gamma;
   orientation.gamma = gamma;
 
   // absolute
   orientation.hasAbsolute = has_absolute;
   orientation.absolute = absolute;
 
-  delegate_->setDeviceOrientationData(orientation);
+  delegate_->SetDeviceOrientationData(orientation);
 }
 
 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 if (orientation_str == "landscape-secondary") {
     orientation = WebScreenOrientationLandscapeSecondary;
   }
 
-  delegate_->setScreenOrientation(orientation);
+  delegate_->SetScreenOrientation(orientation);
 }
 
 void TestRunner::DidChangeBatteryStatus(bool charging,
                                         double chargingTime,
                                         double dischargingTime,
                                         double level) {
   blink::WebBatteryStatus status;
   status.charging = charging;
   status.chargingTime = chargingTime;
   status.dischargingTime = dischargingTime;
   status.level = level;
-  delegate_->didChangeBatteryStatus(status);
+  delegate_->DidChangeBatteryStatus(status);
 }
 
 void TestRunner::ResetBatteryStatus() {
   blink::WebBatteryStatus status;
-  delegate_->didChangeBatteryStatus(status);
+  delegate_->DidChangeBatteryStatus(status);
 }
 
 void TestRunner::DidAcquirePointerLock() {
   DidAcquirePointerLockInternal();
 }
 
 void TestRunner::DidNotAcquirePointerLock() {
   DidNotAcquirePointerLockInternal();
 }
 
 void TestRunner::DidLosePointerLock() {
   DidLosePointerLockInternal();
 }
 
 void TestRunner::SetPointerLockWillFailSynchronously() {
   pointer_lock_planned_result_ = PointerLockWillFailSync;
 }
 
 void TestRunner::SetPointerLockWillRespondAsynchronously() {
   pointer_lock_planned_result_ = PointerLockWillRespondAsync;
 }
 
 void TestRunner::SetPopupBlockingEnabled(bool block_popups) {
-  delegate_->preferences()->java_script_can_open_windows_automatically =
+  delegate_->Preferences()->java_script_can_open_windows_automatically =
       !block_popups;
-  delegate_->applyPreferences();
+  delegate_->ApplyPreferences();
 }
 
 void TestRunner::SetJavaScriptCanAccessClipboard(bool can_access) {
-  delegate_->preferences()->java_script_can_access_clipboard = can_access;
-  delegate_->applyPreferences();
+  delegate_->Preferences()->java_script_can_access_clipboard = can_access;
+  delegate_->ApplyPreferences();
 }
 
 void TestRunner::SetXSSAuditorEnabled(bool enabled) {
-  delegate_->preferences()->xss_auditor_enabled = enabled;
-  delegate_->applyPreferences();
+  delegate_->Preferences()->xss_auditor_enabled = enabled;
+  delegate_->ApplyPreferences();
 }
 
 void TestRunner::SetAllowUniversalAccessFromFileURLs(bool allow) {
-  delegate_->preferences()->allow_universal_access_from_file_urls = allow;
-  delegate_->applyPreferences();
+  delegate_->Preferences()->allow_universal_access_from_file_urls = allow;
+  delegate_->ApplyPreferences();
 }
 
 void TestRunner::SetAllowFileAccessFromFileURLs(bool allow) {
-  delegate_->preferences()->allow_file_access_from_file_urls = allow;
-  delegate_->applyPreferences();
+  delegate_->Preferences()->allow_file_access_from_file_urls = allow;
+  delegate_->ApplyPreferences();
 }
 
 void TestRunner::OverridePreference(const std::string key,
                                     v8::Handle<v8::Value> value) {
-  TestPreferences* prefs = delegate_->preferences();
+  TestPreferences* prefs = delegate_->Preferences();
   if (key == "WebKitDefaultFontSize") {
     prefs->default_font_size = value->Int32Value();
   } else if (key == "WebKitMinimumFontSize") {
     prefs->minimum_font_size = value->Int32Value();
   } else if (key == "WebKitDefaultTextEncodingName") {
     prefs->default_text_encoding_name = V8StringToWebString(value->ToString());
   } else if (key == "WebKitJavaScriptEnabled") {
     prefs->java_script_enabled = value->BooleanValue();
   } else if (key == "WebKitSupportsMultipleWindows") {
     prefs->supports_multiple_windows = value->BooleanValue();
@@ skipping 21 matching lines @@
     prefs->allow_display_of_insecure_content = value->BooleanValue();
   } else if (key == "WebKitAllowRunningInsecureContent") {
     prefs->allow_running_of_insecure_content = value->BooleanValue();
   } else if (key == "WebKitShouldRespectImageOrientation") {
     prefs->should_respect_image_orientation = value->BooleanValue();
   } else if (key == "WebKitWebAudioEnabled") {
     DCHECK(value->BooleanValue());
   } else {
     std::string message("Invalid name for preference: ");
     message.append(key);
-    delegate_->printMessage(std::string("CONSOLE MESSAGE: ") + message + "\n");
+    delegate_->PrintMessage(std::string("CONSOLE MESSAGE: ") + message + "\n");
   }
-  delegate_->applyPreferences();
+  delegate_->ApplyPreferences();
 }
 
 void TestRunner::SetAcceptLanguages(const std::string& accept_languages) {
   proxy_->SetAcceptLanguages(accept_languages);
 }
 
 void TestRunner::SetPluginsEnabled(bool enabled) {
-  delegate_->preferences()->plugins_enabled = enabled;
-  delegate_->applyPreferences();
+  delegate_->Preferences()->plugins_enabled = enabled;
+  delegate_->ApplyPreferences();
 }
 
 void TestRunner::DumpEditingCallbacks() {
   dump_editting_callbacks_ = true;
 }
 
 void TestRunner::DumpAsMarkup() {
   dump_as_markup_ = true;
   generate_pixel_results_ = false;
 }
@@ skipping 139 matching lines @@
 void TestRunner::DumpResourceRequestPriorities() {
   should_dump_resource_priorities_ = true;
 }
 
 void TestRunner::SetUseMockTheme(bool use) {
   use_mock_theme_ = use;
 }
 
 void TestRunner::ShowWebInspector(const std::string& str,
                                   const std::string& frontend_url) {
-  showDevTools(str, frontend_url);
+  ShowDevTools(str, frontend_url);
 }
 
 void TestRunner::WaitUntilExternalURLLoad() {
   wait_until_external_url_load_ = true;
 }
 
 void TestRunner::CloseWebInspector() {
-  delegate_->closeDevTools();
+  delegate_->CloseDevTools();
 }
 
 bool TestRunner::IsChooserShown() {
   return proxy_->IsChooserShown();
 }
 
 void TestRunner::EvaluateInWebInspector(int call_id,
                                         const std::string& script) {
-  delegate_->evaluateInWebInspector(call_id, script);
+  delegate_->EvaluateInWebInspector(call_id, script);
 }
 
 void TestRunner::ClearAllDatabases() {
-  delegate_->clearAllDatabases();
+  delegate_->ClearAllDatabases();
 }
 
 void TestRunner::SetDatabaseQuota(int quota) {
-  delegate_->setDatabaseQuota(quota);
+  delegate_->SetDatabaseQuota(quota);
 }
 
 void TestRunner::SetAlwaysAcceptCookies(bool accept) {
-  delegate_->setAcceptAllCookies(accept);
+  delegate_->SetAcceptAllCookies(accept);
 }
 
 void TestRunner::SetWindowIsKey(bool value) {
-  delegate_->setFocus(proxy_, value);
+  delegate_->SetFocus(proxy_, value);
 }
 
 std::string TestRunner::PathToLocalResource(const std::string& path) {
-  return delegate_->pathToLocalResource(path);
+  return delegate_->PathToLocalResource(path);
 }
 
 void TestRunner::SetBackingScaleFactor(double value,
                                        v8::Handle<v8::Function> callback) {
-  delegate_->setDeviceScaleFactor(value);
-  delegate_->postTask(new InvokeCallbackTask(this, callback));
+  delegate_->SetDeviceScaleFactor(value);
+  delegate_->PostTask(new InvokeCallbackTask(this, callback));
 }
 
 void TestRunner::SetColorProfile(const std::string& name,
                                  v8::Handle<v8::Function> callback) {
-  delegate_->setDeviceColorProfile(name);
-  delegate_->postTask(new InvokeCallbackTask(this, callback));
+  delegate_->SetDeviceColorProfile(name);
+  delegate_->PostTask(new InvokeCallbackTask(this, callback));
 }
 
 void TestRunner::SetPOSIXLocale(const std::string& locale) {
-  delegate_->setLocale(locale);
+  delegate_->SetLocale(locale);
 }
 
 void TestRunner::SetMIDIAccessorResult(bool result) {
   midi_accessor_result_ = result;
 }
 
 void TestRunner::SetMIDISysexPermission(bool value) {
   const std::vector<WebTestProxyBase*>& windowList =
       test_interfaces_->GetWindowList();
   for (unsigned i = 0; i < windowList.size(); ++i)
     windowList.at(i)->GetMIDIClientMock()->setSysexPermission(value);
 }
 
 void TestRunner::GrantWebNotificationPermission(const GURL& origin,
                                                 bool permission_granted) {
-  delegate_->grantWebNotificationPermission(origin, permission_granted);
+  delegate_->GrantWebNotificationPermission(origin, permission_granted);
 }
 
 void TestRunner::ClearWebNotificationPermissions() {
-  delegate_->clearWebNotificationPermissions();
+  delegate_->ClearWebNotificationPermissions();
 }
 
 bool TestRunner::SimulateWebNotificationClick(const std::string& value) {
   return notification_presenter_->SimulateClick(value);
 }
 
 void TestRunner::AddMockSpeechRecognitionResult(const std::string& transcript,
                                                 double confidence) {
   proxy_->GetSpeechRecognizerMock()->AddMockResult(
       WebString::fromUTF8(transcript), confidence);
@@ skipping 112 matching lines @@
 void TestRunner::SetMockPushClientSuccess(const std::string& endpoint,
                                           const std::string& registration_id) {
   proxy_->GetPushClientMock()->SetMockSuccessValues(endpoint, registration_id);
 }
 
 void TestRunner::SetMockPushClientError(const std::string& message) {
   proxy_->GetPushClientMock()->SetMockErrorValues(message);
 }
 
 void TestRunner::LocationChangeDone() {
-  web_history_item_count_ = delegate_->navigationEntryCount();
+  web_history_item_count_ = delegate_->NavigationEntryCount();
 
   // No more new work after the first complete load.
   work_queue_.set_frozen(true);
 
   if (!wait_until_done_)
     work_queue_.ProcessWorkSoon();
 }
 
 void TestRunner::CheckResponseMimeType() {
   // Text output: the test page can request different types of output which we
   // handle here.
   if (!dump_as_text_) {
     std::string mimeType =
         web_view_->mainFrame()->dataSource()->response().mimeType().utf8();
     if (mimeType == "text/plain") {
       dump_as_text_ = true;
       generate_pixel_results_ = false;
     }
   }
 }
 
 void TestRunner::CompleteNotifyDone() {
   if (wait_until_done_ && !topLoadingFrame() && work_queue_.is_empty())
-    delegate_->testFinished();
+    delegate_->TestFinished();
   wait_until_done_ = false;
 }
 
 void TestRunner::DidAcquirePointerLockInternal() {
   pointer_locked_ = true;
   web_view_->didAcquirePointerLock();
 
   // Reset planned result to default.
   pointer_lock_planned_result_ = PointerLockWillSucceed;
 }
 
 void TestRunner::DidNotAcquirePointerLockInternal() {
   DCHECK(!pointer_locked_);
   pointer_locked_ = false;
   web_view_->didNotAcquirePointerLock();
 
   // Reset planned result to default.
   pointer_lock_planned_result_ = PointerLockWillSucceed;
 }
 
 void TestRunner::DidLosePointerLockInternal() {
   bool was_locked = pointer_locked_;
   pointer_locked_ = false;
   if (was_locked)
     web_view_->didLosePointerLock();
 }
 
 }  // namespace content