Abstract class WebTestDelegate to chromium c++ style.

content/shell/renderer/webkit_test_runner.cc

 // Copyright (c) 2012 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/webkit_test_runner.h"
 
 #include <algorithm>
 #include <clocale>
 #include <cmath>
 
@@ skipping 175 matching lines @@
       is_main_window_(false),
       focus_on_next_commit_(false),
       leak_detector_(new LeakDetector(this)) {
 }
 
 WebKitTestRunner::~WebKitTestRunner() {
 }
 
 // WebTestDelegate  -----------------------------------------------------------
 
-void WebKitTestRunner::clearEditCommand() {
+void WebKitTestRunner::ClearEditCommand() {
   render_view()->ClearEditCommands();
 }
 
-void WebKitTestRunner::setEditCommand(const std::string& name,
+void WebKitTestRunner::SetEditCommand(const std::string& name,
                                       const std::string& value) {
   render_view()->SetEditCommandForNextKeyEvent(name, value);
 }
 
-void WebKitTestRunner::setGamepadProvider(
+void WebKitTestRunner::SetGamepadProvider(
     scoped_ptr<RendererGamepadProvider> provider) {
   SetMockGamepadProvider(provider.Pass());
 }
 
-void WebKitTestRunner::setDeviceLightData(const double data) {
+void WebKitTestRunner::SetDeviceLightData(const double data) {
   SetMockDeviceLightData(data);
 }
 
-void WebKitTestRunner::setDeviceMotionData(const WebDeviceMotionData& data) {
+void WebKitTestRunner::SetDeviceMotionData(const WebDeviceMotionData& data) {
   SetMockDeviceMotionData(data);
 }
 
-void WebKitTestRunner::setDeviceOrientationData(
+void WebKitTestRunner::SetDeviceOrientationData(
     const WebDeviceOrientationData& data) {
   SetMockDeviceOrientationData(data);
 }
 
-void WebKitTestRunner::setScreenOrientation(
+void WebKitTestRunner::SetScreenOrientation(
     const WebScreenOrientationType& orientation) {
   MockScreenOrientationClient* mock_client =
       proxy()->GetScreenOrientationClientMock();
   mock_client->UpdateDeviceOrientation(render_view()->GetWebView()->mainFrame(),
                                        orientation);
 }
 
-void WebKitTestRunner::resetScreenOrientation() {
+void WebKitTestRunner::ResetScreenOrientation() {
   MockScreenOrientationClient* mock_client =
       proxy()->GetScreenOrientationClientMock();
   mock_client->ResetData();
 }
 
-void WebKitTestRunner::didChangeBatteryStatus(
+void WebKitTestRunner::DidChangeBatteryStatus(
     const blink::WebBatteryStatus& status) {
   MockBatteryStatusChanged(status);
 }
 
-void WebKitTestRunner::printMessage(const std::string& message) {
+void WebKitTestRunner::PrintMessage(const std::string& message) {
   Send(new ShellViewHostMsg_PrintMessage(routing_id(), message));
 }
 
-void WebKitTestRunner::postTask(WebTask* task) {
+void WebKitTestRunner::PostTask(WebTask* task) {
   Platform::current()->callOnMainThread(InvokeTaskHelper, task);
 }
 
-void WebKitTestRunner::postDelayedTask(WebTask* task, long long ms) {
+void WebKitTestRunner::PostDelayedTask(WebTask* task, long long ms) {
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&WebTask::run, base::Owned(task)),
       base::TimeDelta::FromMilliseconds(ms));
 }
 
-WebString WebKitTestRunner::registerIsolatedFileSystem(
+WebString WebKitTestRunner::RegisterIsolatedFileSystem(
     const blink::WebVector<blink::WebString>& absolute_filenames) {
   std::vector<base::FilePath> files;
   for (size_t i = 0; i < absolute_filenames.size(); ++i)
     files.push_back(base::FilePath::FromUTF16Unsafe(absolute_filenames[i]));
   std::string filesystem_id;
   Send(new ShellViewHostMsg_RegisterIsolatedFileSystem(
       routing_id(), files, &filesystem_id));
   return WebString::fromUTF8(filesystem_id);
 }
 
-long long WebKitTestRunner::getCurrentTimeInMillisecond() {
+long long WebKitTestRunner::GetCurrentTimeInMillisecond() {
   return base::TimeDelta(base::Time::Now() -
                          base::Time::UnixEpoch()).ToInternalValue() /
          base::Time::kMicrosecondsPerMillisecond;
 }
 
-WebString WebKitTestRunner::getAbsoluteWebStringFromUTF8Path(
+WebString WebKitTestRunner::GetAbsoluteWebStringFromUTF8Path(
     const std::string& utf8_path) {
   base::FilePath path = base::FilePath::FromUTF8Unsafe(utf8_path);
   if (!path.IsAbsolute()) {
     GURL base_url =
         net::FilePathToFileURL(test_config_.current_working_directory.Append(
             FILE_PATH_LITERAL("foo")));
     net::FileURLToFilePath(base_url.Resolve(utf8_path), &path);
   }
   return path.AsUTF16Unsafe();
 }
 
-WebURL WebKitTestRunner::localFileToDataURL(const WebURL& file_url) {
+WebURL WebKitTestRunner::LocalFileToDataURL(const WebURL& file_url) {
   base::FilePath local_path;
   if (!net::FileURLToFilePath(file_url, &local_path))
     return WebURL();
 
   std::string contents;
   Send(new ShellViewHostMsg_ReadFileToString(
         routing_id(), local_path, &contents));
 
   std::string contents_base64;
   base::Base64Encode(contents, &contents_base64);
 
   const char data_url_prefix[] = "data:text/css:charset=utf-8;base64,";
   return WebURL(GURL(data_url_prefix + contents_base64));
 }
 
-WebURL WebKitTestRunner::rewriteLayoutTestsURL(const std::string& utf8_url) {
+WebURL WebKitTestRunner::RewriteLayoutTestsURL(const std::string& utf8_url) {
   const char kPrefix[] = "file:///tmp/LayoutTests/";
   const int kPrefixLen = arraysize(kPrefix) - 1;
 
   if (utf8_url.compare(0, kPrefixLen, kPrefix, kPrefixLen))
     return WebURL(GURL(utf8_url));
 
   base::FilePath replace_path =
       ShellRenderProcessObserver::GetInstance()->webkit_source_dir().Append(
           FILE_PATH_LITERAL("LayoutTests/"));
 #if defined(OS_WIN)
   std::string utf8_path = base::WideToUTF8(replace_path.value());
 #else
   std::string utf8_path =
       base::WideToUTF8(base::SysNativeMBToWide(replace_path.value()));
 #endif
   std::string new_url =
       std::string("file://") + utf8_path + utf8_url.substr(kPrefixLen);
   return WebURL(GURL(new_url));
 }
 
-TestPreferences* WebKitTestRunner::preferences() {
+TestPreferences* WebKitTestRunner::Preferences() {
   return &prefs_;
 }
 
-void WebKitTestRunner::applyPreferences() {
+void WebKitTestRunner::ApplyPreferences() {
   WebPreferences prefs = render_view()->GetWebkitPreferences();
   ExportLayoutTestSpecificPreferences(prefs_, &prefs);
   render_view()->SetWebkitPreferences(prefs);
   Send(new ShellViewHostMsg_OverridePreferences(routing_id(), prefs));
 }
 
 std::string WebKitTestRunner::makeURLErrorDescription(
     const WebURLError& error) {
   std::string domain = error.domain.utf8();
   int code = error.reason;
@@ skipping 17 matching lines @@
       break;
     }
   } else {
     DLOG(WARNING) << "Unknown error domain";
   }
 
   return base::StringPrintf("<NSError domain %s, code %d, failing URL \"%s\">",
       domain.c_str(), code, error.unreachableURL.spec().data());
 }
 
-void WebKitTestRunner::useUnfortunateSynchronousResizeMode(bool enable) {
+void WebKitTestRunner::UseUnfortunateSynchronousResizeMode(bool enable) {
   UseSynchronousResizeModeVisitor visitor(enable);
   RenderView::ForEach(&visitor);
 }
 
-void WebKitTestRunner::enableAutoResizeMode(const WebSize& min_size,
+void WebKitTestRunner::EnableAutoResizeMode(const WebSize& min_size,
                                             const WebSize& max_size) {
-  EnableAutoResizeMode(render_view(), min_size, max_size);
+  content::EnableAutoResizeMode(render_view(), min_size, max_size);
 }
 
-void WebKitTestRunner::disableAutoResizeMode(const WebSize& new_size) {
-  DisableAutoResizeMode(render_view(), new_size);
+void WebKitTestRunner::DisableAutoResizeMode(const WebSize& new_size) {
+  content::DisableAutoResizeMode(render_view(), new_size);
   if (!new_size.isEmpty())
     ForceResizeRenderView(render_view(), new_size);
 }
 
-void WebKitTestRunner::clearDevToolsLocalStorage() {
+void WebKitTestRunner::ClearDevToolsLocalStorage() {
   Send(new ShellViewHostMsg_ClearDevToolsLocalStorage(routing_id()));
 }
 
-void WebKitTestRunner::showDevTools(const std::string& settings,
+void WebKitTestRunner::ShowDevTools(const std::string& settings,
                                     const std::string& frontend_url) {
   Send(new ShellViewHostMsg_ShowDevTools(
       routing_id(), settings, frontend_url));
 }
 
-void WebKitTestRunner::closeDevTools() {
+void WebKitTestRunner::CloseDevTools() {
   Send(new ShellViewHostMsg_CloseDevTools(routing_id()));
   WebDevToolsAgent* agent = render_view()->GetWebView()->devToolsAgent();
   if (agent)
     agent->detach();
 }
 
-void WebKitTestRunner::evaluateInWebInspector(long call_id,
+void WebKitTestRunner::EvaluateInWebInspector(long call_id,
                                               const std::string& script) {
   WebDevToolsAgent* agent = render_view()->GetWebView()->devToolsAgent();
   if (agent)
     agent->evaluateInWebInspector(call_id, WebString::fromUTF8(script));
 }
 
-void WebKitTestRunner::clearAllDatabases() {
+void WebKitTestRunner::ClearAllDatabases() {
   Send(new ShellViewHostMsg_ClearAllDatabases(routing_id()));
 }
 
-void WebKitTestRunner::setDatabaseQuota(int quota) {
+void WebKitTestRunner::SetDatabaseQuota(int quota) {
   Send(new ShellViewHostMsg_SetDatabaseQuota(routing_id(), quota));
 }
 
 blink::WebNotificationPresenter::Permission
-WebKitTestRunner::checkWebNotificationPermission(const GURL& origin) {
+WebKitTestRunner::CheckWebNotificationPermission(const GURL& origin) {
   int permission = blink::WebNotificationPresenter::PermissionNotAllowed;
   Send(new ShellViewHostMsg_CheckWebNotificationPermission(
           routing_id(),
           origin,
           &permission));
   return static_cast<blink::WebNotificationPresenter::Permission>(permission);
 }
 
-void WebKitTestRunner::grantWebNotificationPermission(const GURL& origin,
+void WebKitTestRunner::GrantWebNotificationPermission(const GURL& origin,
                                                       bool permission_granted) {
   Send(new ShellViewHostMsg_GrantWebNotificationPermission(
       routing_id(), origin, permission_granted));
 }
 
-void WebKitTestRunner::clearWebNotificationPermissions() {
+void WebKitTestRunner::ClearWebNotificationPermissions() {
   Send(new ShellViewHostMsg_ClearWebNotificationPermissions(routing_id()));
 }
 
-void WebKitTestRunner::setDeviceScaleFactor(float factor) {
-  SetDeviceScaleFactor(render_view(), factor);
+void WebKitTestRunner::SetDeviceScaleFactor(float factor) {
+  content::SetDeviceScaleFactor(render_view(), factor);
 }
 
-void WebKitTestRunner::setDeviceColorProfile(const std::string& name) {
-  SetDeviceColorProfile(render_view(), name);
+void WebKitTestRunner::SetDeviceColorProfile(const std::string& name) {
+  content::SetDeviceColorProfile(render_view(), name);
 }
 
-void WebKitTestRunner::setFocus(WebTestProxyBase* proxy, bool focus) {
+void WebKitTestRunner::SetFocus(WebTestProxyBase* proxy, bool focus) {
   ProxyToRenderViewVisitor visitor(proxy);
   RenderView::ForEach(&visitor);
   if (!visitor.render_view()) {
     NOTREACHED();
     return;
   }
 
   // Check whether the focused view was closed meanwhile.
   if (!WebKitTestRunner::Get(focused_view_))
     focused_view_ = NULL;
 
   if (focus) {
     if (focused_view_ != visitor.render_view()) {
       if (focused_view_)
         SetFocusAndActivate(focused_view_, false);
       SetFocusAndActivate(visitor.render_view(), true);
       focused_view_ = visitor.render_view();
     }
   } else {
     if (focused_view_ == visitor.render_view()) {
       SetFocusAndActivate(visitor.render_view(), false);
       focused_view_ = NULL;
     }
   }
 }
 
-void WebKitTestRunner::setAcceptAllCookies(bool accept) {
+void WebKitTestRunner::SetAcceptAllCookies(bool accept) {
   Send(new ShellViewHostMsg_AcceptAllCookies(routing_id(), accept));
 }
 
-std::string WebKitTestRunner::pathToLocalResource(const std::string& resource) {
+std::string WebKitTestRunner::PathToLocalResource(const std::string& resource) {
 #if defined(OS_WIN)
   if (resource.find("/tmp/") == 0) {
     // We want a temp file.
     GURL base_url = net::FilePathToFileURL(test_config_.temp_path);
     return base_url.Resolve(resource.substr(strlen("/tmp/"))).spec();
   }
 #endif
 
   // Some layout tests use file://// which we resolve as a UNC path. Normalize
   // them to just file:///.
   std::string result = resource;
   while (base::StringToLowerASCII(result).find("file:////") == 0) {
     result = result.substr(0, strlen("file:///")) +
              result.substr(strlen("file:////"));
   }
-  return rewriteLayoutTestsURL(result).spec();
+  return RewriteLayoutTestsURL(result).spec();
 }
 
-void WebKitTestRunner::setLocale(const std::string& locale) {
+void WebKitTestRunner::SetLocale(const std::string& locale) {
   setlocale(LC_ALL, locale.c_str());
 }
 
-void WebKitTestRunner::testFinished() {
+void WebKitTestRunner::TestFinished() {
   if (!is_main_window_) {
     Send(new ShellViewHostMsg_TestFinishedInSecondaryWindow(routing_id()));
     return;
   }
   WebTestInterfaces* interfaces =
       ShellRenderProcessObserver::GetInstance()->test_interfaces();
   interfaces->setTestIsRunning(false);
   if (interfaces->testRunner()->ShouldDumpBackForwardList()) {
     SyncNavigationStateVisitor visitor;
     RenderView::ForEach(&visitor);
     Send(new ShellViewHostMsg_CaptureSessionHistory(routing_id()));
   } else {
     CaptureDump();
   }
 }
 
-void WebKitTestRunner::closeRemainingWindows() {
+void WebKitTestRunner::CloseRemainingWindows() {
   NavigateAwayVisitor visitor(render_view());
   RenderView::ForEach(&visitor);
   Send(new ShellViewHostMsg_CloseRemainingWindows(routing_id()));
 }
 
-void WebKitTestRunner::deleteAllCookies() {
+void WebKitTestRunner::DeleteAllCookies() {
   Send(new ShellViewHostMsg_DeleteAllCookies(routing_id()));
 }
 
-int WebKitTestRunner::navigationEntryCount() {
+int WebKitTestRunner::NavigationEntryCount() {
   return GetLocalSessionHistoryLength(render_view());
 }
 
-void WebKitTestRunner::goToOffset(int offset) {
+void WebKitTestRunner::GoToOffset(int offset) {
   Send(new ShellViewHostMsg_GoToOffset(routing_id(), offset));
 }
 
-void WebKitTestRunner::reload() {
+void WebKitTestRunner::Reload() {
   Send(new ShellViewHostMsg_Reload(routing_id()));
 }
 
-void WebKitTestRunner::loadURLForFrame(const WebURL& url,
-                             const std::string& frame_name) {
+void WebKitTestRunner::LoadURLForFrame(const WebURL& url,
+                                       const std::string& frame_name) {
   Send(new ShellViewHostMsg_LoadURLForFrame(
       routing_id(), url, frame_name));
 }
 
-bool WebKitTestRunner::allowExternalPages() {
+bool WebKitTestRunner::AllowExternalPages() {
   return test_config_.allow_external_pages;
 }
 
-std::string WebKitTestRunner::dumpHistoryForWindow(WebTestProxyBase* proxy) {
+std::string WebKitTestRunner::DumpHistoryForWindow(WebTestProxyBase* proxy) {
   size_t pos = 0;
   std::vector<int>::iterator id;
   for (id = routing_ids_.begin(); id != routing_ids_.end(); ++id, ++pos) {
     RenderView* render_view = RenderView::FromRoutingID(*id);
     if (!render_view) {
       NOTREACHED();
       continue;
     }
     if (WebKitTestRunner::Get(render_view)->proxy() == proxy)
       break;
@@ skipping 138 matching lines @@
 }
 
 void WebKitTestRunner::OnSetTestConfiguration(
     const ShellTestConfiguration& params) {
   test_config_ = params;
   is_main_window_ = true;
 
   ForceResizeRenderView(
       render_view(),
       WebSize(params.initial_size.width(), params.initial_size.height()));
-  setFocus(proxy_, true);
+  SetFocus(proxy_, true);
 
   WebTestInterfaces* interfaces =
       ShellRenderProcessObserver::GetInstance()->test_interfaces();
   interfaces->setTestIsRunning(true);
   interfaces->configureForTestWithURL(params.test_url,
                                       params.enable_pixel_dumping);
 }
 
 void WebKitTestRunner::OnSessionHistory(
     const std::vector<int>& routing_ids,
@@ skipping 28 matching lines @@
 
   leak_detector_->TryLeakDetection(main_frame);
 }
 
 void WebKitTestRunner::ReportLeakDetectionResult(
     const LeakDetectionResult& report) {
   Send(new ShellViewHostMsg_LeakDetectionDone(routing_id(), report));
 }
 
 }  // namespace content