Move LayoutTestMessageFilter-related IPCs to their own message file.

content/shell/renderer/layout_test/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/layout_test/webkit_test_runner.h"
 
 #include <algorithm>
 #include <clocale>
 #include <cmath>
 
@@ skipping 10 matching lines @@
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/common/web_preferences.h"
 #include "content/public/renderer/render_view.h"
 #include "content/public/renderer/render_view_visitor.h"
 #include "content/public/renderer/renderer_gamepad_provider.h"
 #include "content/public/test/layouttest_support.h"
+#include "content/shell/common/layout_test/layout_test_messages.h"
 #include "content/shell/common/shell_messages.h"
 #include "content/shell/common/shell_switches.h"
 #include "content/shell/common/webkit_test_helpers.h"
 #include "content/shell/renderer/layout_test/gc_controller.h"
 #include "content/shell/renderer/layout_test/layout_test_render_process_observer.h"
 #include "content/shell/renderer/layout_test/leak_detector.h"
 #include "content/shell/renderer/test_runner/mock_screen_orientation_client.h"
 #include "content/shell/renderer/test_runner/web_task.h"
 #include "content/shell/renderer/test_runner/web_test_interfaces.h"
 #include "content/shell/renderer/test_runner/web_test_proxy.h"
@@ skipping 213 matching lines @@
       base::Bind(&WebTask::run, base::Owned(task)),
       base::TimeDelta::FromMilliseconds(ms));
 }
 
 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(
+  Send(new LayoutTestHostMsg_RegisterIsolatedFileSystem(
       routing_id(), files, &filesystem_id));
   return WebString::fromUTF8(filesystem_id);
 }
 
 long long WebKitTestRunner::GetCurrentTimeInMillisecond() {
   return base::TimeDelta(base::Time::Now() -
                          base::Time::UnixEpoch()).ToInternalValue() /
          base::Time::kMicrosecondsPerMillisecond;
 }
 
 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) {
   base::FilePath local_path;
   if (!net::FileURLToFilePath(file_url, &local_path))
     return WebURL();
 
   std::string contents;
-  Send(new ShellViewHostMsg_ReadFileToString(
+  Send(new LayoutTestHostMsg_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) {
@@ skipping 93 matching lines @@
 }
 
 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() {
-  Send(new ShellViewHostMsg_ClearAllDatabases(routing_id()));
+  Send(new LayoutTestHostMsg_ClearAllDatabases(routing_id()));
 }
 
 void WebKitTestRunner::SetDatabaseQuota(int quota) {
-  Send(new ShellViewHostMsg_SetDatabaseQuota(routing_id(), quota));
+  Send(new LayoutTestHostMsg_SetDatabaseQuota(routing_id(), quota));
 }
 
 blink::WebNotificationPresenter::Permission
 WebKitTestRunner::CheckWebNotificationPermission(const GURL& origin) {
   int permission = blink::WebNotificationPresenter::PermissionNotAllowed;
-  Send(new ShellViewHostMsg_CheckWebNotificationPermission(
+  Send(new LayoutTestHostMsg_CheckWebNotificationPermission(
           routing_id(),
           origin,
           &permission));
   return static_cast<blink::WebNotificationPresenter::Permission>(permission);
 }
 
 void WebKitTestRunner::GrantWebNotificationPermission(const GURL& origin,
                                                       bool permission_granted) {
-  Send(new ShellViewHostMsg_GrantWebNotificationPermission(
+  Send(new LayoutTestHostMsg_GrantWebNotificationPermission(
       routing_id(), origin, permission_granted));
 }
 
 void WebKitTestRunner::ClearWebNotificationPermissions() {
-  Send(new ShellViewHostMsg_ClearWebNotificationPermissions(routing_id()));
+  Send(new LayoutTestHostMsg_ClearWebNotificationPermissions(routing_id()));
 }
 
 void WebKitTestRunner::SimulateWebNotificationClick(const std::string& title) {
-  Send(new ShellViewHostMsg_SimulateWebNotificationClick(routing_id(), title));
+  Send(new LayoutTestHostMsg_SimulateWebNotificationClick(routing_id(), title));
 }
 
 void WebKitTestRunner::SetDeviceScaleFactor(float factor) {
   content::SetDeviceScaleFactor(render_view(), factor);
 }
 
 void WebKitTestRunner::SetDeviceColorProfile(const std::string& name) {
   content::SetDeviceColorProfile(render_view(), name);
 }
 
@@ skipping 18 matching lines @@
     }
   } else {
     if (focused_view_ == visitor.render_view()) {
       SetFocusAndActivate(visitor.render_view(), false);
       focused_view_ = NULL;
     }
   }
 }
 
 void WebKitTestRunner::SetAcceptAllCookies(bool accept) {
-  Send(new ShellViewHostMsg_AcceptAllCookies(routing_id(), accept));
+  Send(new LayoutTestHostMsg_AcceptAllCookies(routing_id(), accept));
 }
 
 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
@@ skipping 29 matching lines @@
   }
 }
 
 void WebKitTestRunner::CloseRemainingWindows() {
   NavigateAwayVisitor visitor(render_view());
   RenderView::ForEach(&visitor);
   Send(new ShellViewHostMsg_CloseRemainingWindows(routing_id()));
 }
 
 void WebKitTestRunner::DeleteAllCookies() {
-  Send(new ShellViewHostMsg_DeleteAllCookies(routing_id()));
+  Send(new LayoutTestHostMsg_DeleteAllCookies(routing_id()));
 }
 
 int WebKitTestRunner::NavigationEntryCount() {
   return GetLocalSessionHistoryLength(render_view());
 }
 
 void WebKitTestRunner::GoToOffset(int offset) {
   Send(new ShellViewHostMsg_GoToOffset(routing_id(), offset));
 }
 
@@ skipping 218 matching lines @@
 
   leak_detector_->TryLeakDetection(main_frame);
 }
 
 void WebKitTestRunner::ReportLeakDetectionResult(
     const LeakDetectionResult& report) {
   Send(new ShellViewHostMsg_LeakDetectionDone(routing_id(), report));
 }
 
 }  // namespace content