Move //components/test_runner back into //content/shell

content/shell/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 "content/shell/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/nullable_string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.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_document_subresource_filter.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_common.h"
-#include "components/test_runner/test_interfaces.h"
-#include "components/test_runner/test_preferences.h"
-#include "components/test_runner/test_runner_for_specific_view.h"
-#include "components/test_runner/web_test_delegate.h"
-#include "components/test_runner/web_view_test_proxy.h"
+#include "content/shell/test_runner/layout_and_paint_async_then.h"
+#include "content/shell/test_runner/layout_dump.h"
+#include "content/shell/test_runner/mock_content_settings_client.h"
+#include "content/shell/test_runner/mock_credential_manager_client.h"
+#include "content/shell/test_runner/mock_screen_orientation_client.h"
+#include "content/shell/test_runner/mock_web_document_subresource_filter.h"
+#include "content/shell/test_runner/mock_web_speech_recognizer.h"
+#include "content/shell/test_runner/mock_web_user_media_client.h"
+#include "content/shell/test_runner/pixel_dump.h"
+#include "content/shell/test_runner/spell_check_client.h"
+#include "content/shell/test_runner/test_common.h"
+#include "content/shell/test_runner/test_interfaces.h"
+#include "content/shell/test_runner/test_preferences.h"
+#include "content/shell/test_runner/test_runner_for_specific_view.h"
+#include "content/shell/test_runner/web_test_delegate.h"
+#include "content/shell/test_runner/web_view_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/WebCanvas.h"
 #include "third_party/WebKit/public/platform/WebData.h"
 #include "third_party/WebKit/public/platform/WebPasswordCredential.h"
 #include "third_party/WebKit/public/platform/WebPoint.h"
 #include "third_party/WebKit/public/platform/WebURLResponse.h"
@@ skipping 224 matching lines @@
                                         const std::string& password);
   void ClearMockCredentialManagerResponse();
   bool CallShouldCloseOnWebView();
   bool DisableAutoResizeMode(int new_width, int new_height);
   bool EnableAutoResizeMode(int min_width,
                             int min_height,
                             int max_width,
                             int max_height);
   std::string EvaluateInWebInspectorOverlay(const std::string& script);
   v8::Local<v8::Value> EvaluateScriptInIsolatedWorldAndReturnValue(
-      int world_id, const std::string& script);
+      int world_id,
+      const std::string& script);
   bool FindString(const std::string& search_text,
                   const std::vector<std::string>& options_array);
   bool HasCustomPageSizeStyle(int page_index);
   bool IsChooserShown();
 
   bool IsCommandEnabled(const std::string& command);
   std::string PathToLocalResource(const std::string& path);
   std::string PlatformName();
   std::string SelectionAsMarkup();
   std::string TooltipText();
 
   int WebHistoryItemCount();
   int WindowCount();
 
   base::WeakPtr<TestRunner> runner_;
   base::WeakPtr<TestRunnerForSpecificView> view_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(TestRunnerBindings);
 };
 
-gin::WrapperInfo TestRunnerBindings::kWrapperInfo = {
-    gin::kEmbedderNativeGin};
+gin::WrapperInfo TestRunnerBindings::kWrapperInfo = {gin::kEmbedderNativeGin};
 
 // static
 void TestRunnerBindings::Install(
     base::WeakPtr<TestRunner> test_runner,
     base::WeakPtr<TestRunnerForSpecificView> view_test_runner,
     WebLocalFrame* frame) {
   v8::Isolate* isolate = blink::mainThreadIsolate();
   v8::HandleScope handle_scope(isolate);
   v8::Local<v8::Context> context = frame->mainWorldScriptContext();
   if (context.IsEmpty())
@@ skipping 392 matching lines @@
   return false;
 }
 
 bool TestRunnerBindings::CallShouldCloseOnWebView() {
   if (view_runner_)
     return view_runner_->CallShouldCloseOnWebView();
   return false;
 }
 
 void TestRunnerBindings::SetDomainRelaxationForbiddenForURLScheme(
-    bool forbidden, const std::string& scheme) {
+    bool forbidden,
+    const std::string& scheme) {
   if (view_runner_)
     view_runner_->SetDomainRelaxationForbiddenForURLScheme(forbidden, scheme);
 }
 
 void TestRunnerBindings::SetDumpConsoleMessages(bool enabled) {
   if (runner_)
     runner_->SetDumpConsoleMessages(enabled);
 }
 
 void TestRunnerBindings::SetDumpJavaScriptDialogs(bool enabled) {
@@ skipping 35 matching lines @@
     runner_->spellcheck_->SetSpellCheckResolvedCallback(callback);
 }
 
 void TestRunnerBindings::RemoveSpellCheckResolvedCallback() {
   if (runner_)
     runner_->spellcheck_->RemoveSpellCheckResolvedCallback();
 }
 
 v8::Local<v8::Value>
 TestRunnerBindings::EvaluateScriptInIsolatedWorldAndReturnValue(
-    int world_id, const std::string& script) {
+    int world_id,
+    const std::string& script) {
   if (!view_runner_ || world_id <= 0 || world_id >= (1 << 29))
     return v8::Local<v8::Value>();
   return view_runner_->EvaluateScriptInIsolatedWorldAndReturnValue(world_id,
                                                                    script);
 }
 
 void TestRunnerBindings::EvaluateScriptInIsolatedWorld(
-    int world_id, const std::string& script) {
+    int world_id,
+    const std::string& script) {
   if (view_runner_ && world_id > 0 && world_id < (1 << 29))
     view_runner_->EvaluateScriptInIsolatedWorld(world_id, script);
 }
 
 void TestRunnerBindings::SetIsolatedWorldSecurityOrigin(
-    int world_id, v8::Local<v8::Value> origin) {
+    int world_id,
+    v8::Local<v8::Value> origin) {
   if (view_runner_)
     view_runner_->SetIsolatedWorldSecurityOrigin(world_id, origin);
 }
 
 void TestRunnerBindings::SetIsolatedWorldContentSecurityPolicy(
-    int world_id, const std::string& policy) {
+    int world_id,
+    const std::string& policy) {
   if (view_runner_)
     view_runner_->SetIsolatedWorldContentSecurityPolicy(world_id, policy);
 }
 
 void TestRunnerBindings::AddOriginAccessWhitelistEntry(
     const std::string& source_origin,
     const std::string& destination_protocol,
     const std::string& destination_host,
     bool allow_destination_subdomains) {
   if (runner_) {
-    runner_->AddOriginAccessWhitelistEntry(source_origin,
-                                           destination_protocol,
+    runner_->AddOriginAccessWhitelistEntry(source_origin, destination_protocol,
                                            destination_host,
                                            allow_destination_subdomains);
   }
 }
 
 void TestRunnerBindings::RemoveOriginAccessWhitelistEntry(
     const std::string& source_origin,
     const std::string& destination_protocol,
     const std::string& destination_host,
     bool allow_destination_subdomains) {
   if (runner_) {
-    runner_->RemoveOriginAccessWhitelistEntry(source_origin,
-                                              destination_protocol,
-                                              destination_host,
-                                              allow_destination_subdomains);
+    runner_->RemoveOriginAccessWhitelistEntry(
+        source_origin, destination_protocol, destination_host,
+        allow_destination_subdomains);
   }
 }
 
 bool TestRunnerBindings::HasCustomPageSizeStyle(int page_index) {
   if (view_runner_)
     return view_runner_->HasCustomPageSizeStyle(page_index);
   return false;
 }
 
 void TestRunnerBindings::ForceRedSelectionColors() {
@@ skipping 38 matching lines @@
 void TestRunnerBindings::UseUnfortunateSynchronousResizeMode() {
   if (runner_)
     runner_->UseUnfortunateSynchronousResizeMode();
 }
 
 bool TestRunnerBindings::EnableAutoResizeMode(int min_width,
                                               int min_height,
                                               int max_width,
                                               int max_height) {
   if (runner_) {
-    return runner_->EnableAutoResizeMode(min_width, min_height,
-                                         max_width, max_height);
+    return runner_->EnableAutoResizeMode(min_width, min_height, max_width,
+                                         max_height);
   }
   return false;
 }
 
 bool TestRunnerBindings::DisableAutoResizeMode(int new_width, int new_height) {
   if (runner_)
     return runner_->DisableAutoResizeMode(new_width, new_height);
   return false;
 }
 
@@ skipping 45 matching lines @@
   args->GetNext(&has_acceleration_including_gravity_z);
   args->GetNext(&acceleration_including_gravity_z);
   args->GetNext(&has_rotation_rate_alpha);
   args->GetNext(&rotation_rate_alpha);
   args->GetNext(&has_rotation_rate_beta);
   args->GetNext(&rotation_rate_beta);
   args->GetNext(&has_rotation_rate_gamma);
   args->GetNext(&rotation_rate_gamma);
   args->GetNext(&interval);
 
-  runner_->SetMockDeviceMotion(has_acceleration_x, acceleration_x,
-                               has_acceleration_y, acceleration_y,
-                               has_acceleration_z, acceleration_z,
-                               has_acceleration_including_gravity_x,
-                               acceleration_including_gravity_x,
-                               has_acceleration_including_gravity_y,
-                               acceleration_including_gravity_y,
-                               has_acceleration_including_gravity_z,
-                               acceleration_including_gravity_z,
-                               has_rotation_rate_alpha,
-                               rotation_rate_alpha,
-                               has_rotation_rate_beta,
-                               rotation_rate_beta,
-                               has_rotation_rate_gamma,
-                               rotation_rate_gamma,
-                               interval);
+  runner_->SetMockDeviceMotion(
+      has_acceleration_x, acceleration_x, has_acceleration_y, acceleration_y,
+      has_acceleration_z, acceleration_z, has_acceleration_including_gravity_x,
+      acceleration_including_gravity_x, has_acceleration_including_gravity_y,
+      acceleration_including_gravity_y, has_acceleration_including_gravity_z,
+      acceleration_including_gravity_z, has_rotation_rate_alpha,
+      rotation_rate_alpha, has_rotation_rate_beta, rotation_rate_beta,
+      has_rotation_rate_gamma, rotation_rate_gamma, interval);
 }
 
 void TestRunnerBindings::SetMockDeviceOrientation(gin::Arguments* args) {
   if (!runner_)
     return;
 
   bool has_alpha = false;
   double alpha = 0.0;
   bool has_beta = false;
   double beta = 0.0;
   bool has_gamma = false;
   double gamma = 0.0;
   bool absolute = false;
 
   args->GetNext(&has_alpha);
   args->GetNext(&alpha);
   args->GetNext(&has_beta);
   args->GetNext(&beta);
   args->GetNext(&has_gamma);
   args->GetNext(&gamma);
   args->GetNext(&absolute);
 
-  runner_->SetMockDeviceOrientation(has_alpha, alpha,
-                                    has_beta, beta,
-                                    has_gamma, gamma,
-                                    absolute);
+  runner_->SetMockDeviceOrientation(has_alpha, alpha, has_beta, beta, has_gamma,
+                                    gamma, absolute);
 }
 
 void TestRunnerBindings::SetMockScreenOrientation(
     const std::string& orientation) {
   if (!runner_)
     return;
 
   runner_->SetMockScreenOrientation(orientation);
 }
 
@@ skipping 319 matching lines @@
     view_runner_->SetWindowIsKey(value);
 }
 
 std::string TestRunnerBindings::PathToLocalResource(const std::string& path) {
   if (runner_)
     return runner_->PathToLocalResource(path);
   return std::string();
 }
 
 void TestRunnerBindings::SetBackingScaleFactor(
-    double value, v8::Local<v8::Function> callback) {
+    double value,
+    v8::Local<v8::Function> callback) {
   if (view_runner_)
     view_runner_->SetBackingScaleFactor(value, callback);
 }
 
-void TestRunnerBindings::EnableUseZoomForDSF(
-    v8::Local<v8::Function> callback) {
+void TestRunnerBindings::EnableUseZoomForDSF(v8::Local<v8::Function> callback) {
   if (view_runner_)
     view_runner_->EnableUseZoomForDSF(callback);
 }
 
-void TestRunnerBindings::SetColorProfile(
-    const std::string& name, v8::Local<v8::Function> callback) {
+void TestRunnerBindings::SetColorProfile(const std::string& name,
+                                         v8::Local<v8::Function> callback) {
   if (view_runner_)
     view_runner_->SetColorProfile(name, callback);
 }
 
 void TestRunnerBindings::SetBluetoothFakeAdapter(
     const std::string& adapter_name,
     v8::Local<v8::Function> callback) {
   if (view_runner_)
     view_runner_->SetBluetoothFakeAdapter(adapter_name, callback);
 }
@@ skipping 49 matching lines @@
 }
 
 void TestRunnerBindings::SimulateWebNotificationClose(const std::string& title,
                                                       bool by_user) {
   if (!runner_)
     return;
   runner_->SimulateWebNotificationClose(title, by_user);
 }
 
 void TestRunnerBindings::AddMockSpeechRecognitionResult(
-    const std::string& transcript, double confidence) {
+    const std::string& transcript,
+    double confidence) {
   if (runner_)
     runner_->AddMockSpeechRecognitionResult(transcript, confidence);
 }
 
 void TestRunnerBindings::SetMockSpeechRecognitionError(
-    const std::string& error, const std::string& message) {
+    const std::string& error,
+    const std::string& message) {
   if (runner_)
     runner_->SetMockSpeechRecognitionError(error, message);
 }
 
 void TestRunnerBindings::SetMockCredentialManagerResponse(
     const std::string& id,
     const std::string& name,
     const std::string& avatar,
     const std::string& password) {
   if (runner_)
@@ skipping 37 matching lines @@
     view_runner_->GetManifestThen(callback);
 }
 
 void TestRunnerBindings::CapturePixelsAsyncThen(
     v8::Local<v8::Function> callback) {
   if (view_runner_)
     view_runner_->CapturePixelsAsyncThen(callback);
 }
 
 void TestRunnerBindings::CopyImageAtAndCapturePixelsAsyncThen(
-    int x, int y, v8::Local<v8::Function> callback) {
+    int x,
+    int y,
+    v8::Local<v8::Function> callback) {
   if (view_runner_)
     view_runner_->CopyImageAtAndCapturePixelsAsyncThen(x, y, callback);
 }
 
 void TestRunnerBindings::SetCustomTextOutput(const std::string& output) {
   if (runner_)
     runner_->setCustomTextOutput(output);
 }
 
 void TestRunnerBindings::SetViewSourceForFrame(const std::string& name,
                                                bool enabled) {
   if (view_runner_)
     view_runner_->SetViewSourceForFrame(name, enabled);
 }
 
 void TestRunnerBindings::SetPermission(const std::string& name,
                                        const std::string& value,
                                        const std::string& origin,
                                        const std::string& embedding_origin) {
   if (!runner_)
     return;
 
-  return runner_->SetPermission(
-      name, value, GURL(origin), GURL(embedding_origin));
+  return runner_->SetPermission(name, value, GURL(origin),
+                                GURL(embedding_origin));
 }
 
 void TestRunnerBindings::DispatchBeforeInstallPromptEvent(
     const std::vector<std::string>& event_platforms,
     v8::Local<v8::Function> callback) {
   if (!view_runner_)
     return;
 
   return view_runner_->DispatchBeforeInstallPromptEvent(event_platforms,
                                                         callback);
@@ skipping 34 matching lines @@
 void TestRunnerBindings::ForceNextWebGLContextCreationToFail() {
   if (view_runner_)
     view_runner_->ForceNextWebGLContextCreationToFail();
 }
 
 void TestRunnerBindings::ForceNextDrawingBufferCreationToFail() {
   if (view_runner_)
     view_runner_->ForceNextDrawingBufferCreationToFail();
 }
 
-void TestRunnerBindings::NotImplemented(const gin::Arguments& args) {
-}
+void TestRunnerBindings::NotImplemented(const gin::Arguments& args) {}
 
 TestRunner::WorkQueue::WorkQueue(TestRunner* controller)
     : frozen_(false), controller_(controller), weak_factory_(this) {}
 
 TestRunner::WorkQueue::~WorkQueue() {
   Reset();
 }
 
 void TestRunner::WorkQueue::ProcessWorkSoon() {
   if (controller_->topLoadingFrame())
@@ skipping 173 matching lines @@
 
 bool TestRunner::ShouldGeneratePixelResults() {
   CheckResponseMimeType();
   return layout_test_runtime_flags_.generate_pixel_results();
 }
 
 bool TestRunner::shouldStayOnPageAfterHandlingBeforeUnload() const {
   return layout_test_runtime_flags_.stay_on_page_after_handling_before_unload();
 }
 
-
 void TestRunner::setShouldGeneratePixelResults(bool value) {
   layout_test_runtime_flags_.set_generate_pixel_results(value);
   OnLayoutTestRuntimeFlagsChanged();
 }
 
 bool TestRunner::ShouldDumpAsAudio() const {
   return dump_as_audio_;
 }
 
 void TestRunner::GetAudioData(std::vector<unsigned char>* buffer_view) const {
@@ skipping 205 matching lines @@
 }
 
 bool TestRunner::policyDelegateShouldNotifyDone() const {
   return layout_test_runtime_flags_.policy_delegate_should_notify_done();
 }
 
 void TestRunner::setToolTipText(const WebString& text) {
   tooltip_text_ = text.utf8();
 }
 
-void TestRunner::setDragImage(
-    const blink::WebImage& 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 layout_test_runtime_flags_.dump_navigation_policy();
 }
 
 midi::mojom::Result TestRunner::midiAccessorResult() {
   return midi_accessor_result_;
 }
 
 void TestRunner::ClearDevToolsLocalStorage() {
   delegate_->ClearDevToolsLocalStorage();
 }
 
 void TestRunner::SetV8CacheDisabled(bool disabled) {
   if (!main_view_) {
     disable_v8_cache_ = disabled;
     return;
   }
-  main_view_->settings()->setV8CacheOptions(disabled ?
-      blink::WebSettings::V8CacheOptionsNone :
-      blink::WebSettings::V8CacheOptionsDefault);
+  main_view_->settings()->setV8CacheOptions(
+      disabled ? blink::WebSettings::V8CacheOptionsNone
+               : blink::WebSettings::V8CacheOptionsDefault);
 }
 
 void TestRunner::ShowDevTools(const std::string& settings,
                               const std::string& frontend_url) {
   delegate_->ShowDevTools(settings, frontend_url);
 }
 
 class WorkItemBackForward : public TestRunner::WorkItem {
  public:
   WorkItemBackForward(int distance) : distance_(distance) {}
 
   bool Run(WebTestDelegate* delegate, WebView*) override {
     delegate->GoToOffset(distance_);
-    return true; // FIXME: Did it really start a navigation?
+    return true;  // FIXME: Did it really start a navigation?
   }
 
  private:
   int distance_;
 };
 
 void TestRunner::WaitUntilDone() {
   layout_test_runtime_flags_.set_wait_until_done(true);
   OnLayoutTestRuntimeFlagsChanged();
 }
@@ skipping 13 matching lines @@
     return true;
   }
 };
 
 void TestRunner::QueueReload() {
   work_queue_.AddWork(new WorkItemReload());
 }
 
 class WorkItemLoadingScript : public TestRunner::WorkItem {
  public:
-  WorkItemLoadingScript(const std::string& script)
-      : script_(script) {}
+  WorkItemLoadingScript(const std::string& script) : script_(script) {}
 
   bool Run(WebTestDelegate*, WebView* web_view) override {
     web_view->mainFrame()->executeScript(
         WebScriptSource(WebString::fromUTF8(script_)));
-    return true; // FIXME: Did it really start a navigation?
+    return true;  // FIXME: Did it really start a navigation?
   }
 
  private:
   std::string script_;
 };
 
 void TestRunner::QueueLoadingScript(const std::string& script) {
   work_queue_.AddWork(new WorkItemLoadingScript(script));
 }
 
 class WorkItemNonLoadingScript : public TestRunner::WorkItem {
  public:
-  WorkItemNonLoadingScript(const std::string& script)
-      : script_(script) {}
+  WorkItemNonLoadingScript(const std::string& script) : script_(script) {}
 
   bool Run(WebTestDelegate*, WebView* web_view) override {
     web_view->mainFrame()->executeScript(
         WebScriptSource(WebString::fromUTF8(script_)));
     return false;
   }
 
  private:
   std::string script_;
 };
 
 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) {}
 
   bool Run(WebTestDelegate* delegate, WebView*) override {
     delegate->LoadURLForFrame(url_, target_);
-    return true; // FIXME: Did it really start a navigation?
+    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) {
   if (!main_view_)
     return;
@@ skipping 40 matching lines @@
 void TestRunner::AddOriginAccessWhitelistEntry(
     const std::string& source_origin,
     const std::string& destination_protocol,
     const std::string& destination_host,
     bool allow_destination_subdomains) {
   WebURL url((GURL(source_origin)));
   if (!url.isValid())
     return;
 
   WebSecurityPolicy::addOriginAccessWhitelistEntry(
-      url,
-      WebString::fromUTF8(destination_protocol),
-      WebString::fromUTF8(destination_host),
-      allow_destination_subdomains);
+      url, WebString::fromUTF8(destination_protocol),
+      WebString::fromUTF8(destination_host), allow_destination_subdomains);
 }
 
 void TestRunner::RemoveOriginAccessWhitelistEntry(
     const std::string& source_origin,
     const std::string& destination_protocol,
     const std::string& destination_host,
     bool allow_destination_subdomains) {
   WebURL url((GURL(source_origin)));
   if (!url.isValid())
     return;
 
   WebSecurityPolicy::removeOriginAccessWhitelistEntry(
-      url,
-      WebString::fromUTF8(destination_protocol),
-      WebString::fromUTF8(destination_host),
-      allow_destination_subdomains);
+      url, WebString::fromUTF8(destination_protocol),
+      WebString::fromUTF8(destination_host), allow_destination_subdomains);
 }
 
 void TestRunner::SetTextSubpixelPositioning(bool value) {
 #if defined(__linux__) || defined(ANDROID)
   // Since FontConfig doesn't provide a variable to control subpixel
   // positioning, we'll fall back to setting it globally for all fonts.
   WebFontRendering::setSubpixelPositioning(value);
 #endif
 }
 
@@ skipping 18 matching lines @@
 }
 
 void TestRunner::SetMockDeviceLight(double value) {
   delegate_->SetDeviceLightData(value);
 }
 
 void TestRunner::ResetDeviceLight() {
   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,
-    bool has_acceleration_including_gravity_z,
-    double acceleration_including_gravity_z,
-    bool has_rotation_rate_alpha, double rotation_rate_alpha,
-    bool has_rotation_rate_beta, double rotation_rate_beta,
-    bool has_rotation_rate_gamma, double rotation_rate_gamma,
-    double interval) {
+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,
+                                     bool has_acceleration_including_gravity_z,
+                                     double acceleration_including_gravity_z,
+                                     bool has_rotation_rate_alpha,
+                                     double rotation_rate_alpha,
+                                     bool has_rotation_rate_beta,
+                                     double rotation_rate_beta,
+                                     bool has_rotation_rate_gamma,
+                                     double rotation_rate_gamma,
+                                     double interval) {
   WebDeviceMotionData motion;
 
   // acceleration
   motion.hasAccelerationX = has_acceleration_x;
   motion.accelerationX = acceleration_x;
   motion.hasAccelerationY = has_acceleration_y;
   motion.accelerationY = acceleration_y;
   motion.hasAccelerationZ = has_acceleration_z;
   motion.accelerationZ = acceleration_z;
 
@@ skipping 15 matching lines @@
   motion.rotationRateBeta = rotation_rate_beta;
   motion.hasRotationRateGamma = has_rotation_rate_gamma;
   motion.rotationRateGamma = rotation_rate_gamma;
 
   // interval
   motion.interval = interval;
 
   delegate_->SetDeviceMotionData(motion);
 }
 
-void TestRunner::SetMockDeviceOrientation(bool has_alpha, double alpha,
-                                          bool has_beta, double beta,
-                                          bool has_gamma, double gamma,
+void TestRunner::SetMockDeviceOrientation(bool has_alpha,
+                                          double alpha,
+                                          bool has_beta,
+                                          double beta,
+                                          bool has_gamma,
+                                          double gamma,
                                           bool absolute) {
   WebDeviceOrientationData orientation;
 
   // alpha
   orientation.hasAlpha = has_alpha;
   orientation.alpha = alpha;
 
   // beta
   orientation.hasBeta = has_beta;
   orientation.beta = beta;
@@ skipping 543 matching lines @@
 
 void TestRunner::NotifyDone() {
   if (layout_test_runtime_flags_.wait_until_done() && !topLoadingFrame() &&
       !will_navigate_ && work_queue_.is_empty())
     delegate_->TestFinished();
   layout_test_runtime_flags_.set_wait_until_done(false);
   OnLayoutTestRuntimeFlagsChanged();
 }
 
 }  // namespace test_runner