Clean up Automation and Chrome Frame IPC code.

chrome/test/automation/automation_proxy.cc

 // Copyright (c) 2010 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 "chrome/test/automation/automation_proxy.h"
 
 #include <gtest/gtest.h>
 
 #include <sstream>
 
@@ skipping 209 matching lines @@
 void AutomationProxy::SignalInitialLoads() {
   initial_loads_complete_.Signal();
 }
 
 void AutomationProxy::SignalNewTabUITab(int load_time) {
   new_tab_ui_load_time_ = load_time;
   new_tab_ui_load_complete_.Signal();
 }
 
 bool AutomationProxy::SavePackageShouldPromptUser(bool should_prompt) {
-  return Send(new AutomationMsg_SavePackageShouldPromptUser(0, should_prompt));
+  return Send(new AutomationMsg_SavePackageShouldPromptUser(should_prompt));
 }
 
 scoped_refptr<ExtensionProxy> AutomationProxy::InstallExtension(
     const FilePath& crx_file, bool with_ui) {
   int handle = 0;
-  if (!Send(new AutomationMsg_InstallExtensionAndGetHandle(0, crx_file, with_ui,
+  if (!Send(new AutomationMsg_InstallExtensionAndGetHandle(crx_file, with_ui,
                                                            &handle)))
     return NULL;
 
   return ProxyObjectFromHandle<ExtensionProxy>(handle);
 }
 
 void AutomationProxy::EnsureExtensionTestResult() {
   bool result;
   std::string message;
-  if (!Send(new AutomationMsg_WaitForExtensionTestResult(0, &result,
+  if (!Send(new AutomationMsg_WaitForExtensionTestResult(&result,
                                                          &message))) {
     FAIL() << "Could not send WaitForExtensionTestResult message";
     return;
   }
   ASSERT_TRUE(result) << "Extension test message: " << message;
 }
 
 bool AutomationProxy::GetEnabledExtensions(
     std::vector<FilePath>* extension_directories) {
-  return Send(new AutomationMsg_GetEnabledExtensions(
-      0, extension_directories));
+  return Send(new AutomationMsg_GetEnabledExtensions(extension_directories));
 }
 
 bool AutomationProxy::GetBrowserWindowCount(int* num_windows) {
   if (!num_windows) {
     NOTREACHED();
     return false;
   }
 
-  return Send(new AutomationMsg_BrowserWindowCount(0, num_windows));
+  return Send(new AutomationMsg_BrowserWindowCount(num_windows));
 }
 
 bool AutomationProxy::GetNormalBrowserWindowCount(int* num_windows) {
   if (!num_windows) {
     NOTREACHED();
     return false;
   }
 
-  return Send(new AutomationMsg_NormalBrowserWindowCount(0, num_windows));
+  return Send(new AutomationMsg_NormalBrowserWindowCount(num_windows));
 }
 
 bool AutomationProxy::WaitForWindowCountToBecome(int count) {
   bool wait_success = false;
   if (!Send(new AutomationMsg_WaitForBrowserWindowCountToBecome(
-                0, count, &wait_success))) {
+                count, &wait_success))) {
     return false;
   }
   return wait_success;
 }
 
 bool AutomationProxy::GetShowingAppModalDialog(
     bool* showing_app_modal_dialog,
     MessageBoxFlags::DialogButton* button) {
   if (!showing_app_modal_dialog || !button) {
     NOTREACHED();
     return false;
   }
 
   int button_int = 0;
 
   if (!Send(new AutomationMsg_ShowingAppModalDialog(
-                0, showing_app_modal_dialog, &button_int))) {
+                showing_app_modal_dialog, &button_int))) {
     return false;
   }
 
   *button = static_cast<MessageBoxFlags::DialogButton>(button_int);
   return true;
 }
 
 bool AutomationProxy::ClickAppModalDialogButton(
     MessageBoxFlags::DialogButton button) {
   bool succeeded = false;
 
   if (!Send(new AutomationMsg_ClickAppModalDialogButton(
-                0, button, &succeeded))) {
+                button, &succeeded))) {
     return false;
   }
 
   return succeeded;
 }
 
 bool AutomationProxy::WaitForAppModalDialog() {
   bool wait_success = false;
-  if (!Send(new AutomationMsg_WaitForAppModalDialogToBeShown(0, &wait_success)))
+  if (!Send(new AutomationMsg_WaitForAppModalDialogToBeShown(&wait_success)))
     return false;
   return wait_success;
 }
 
 bool AutomationProxy::IsURLDisplayed(GURL url) {
   int window_count;
   if (!GetBrowserWindowCount(&window_count))
     return false;
 
   for (int i = 0; i < window_count; i++) {
@@ skipping 17 matching lines @@
       if (tab_url == url)
         return true;
     }
   }
 
   return false;
 }
 
 bool AutomationProxy::GetMetricEventDuration(const std::string& event_name,
                                              int* duration_ms) {
-  return Send(new AutomationMsg_GetMetricEventDuration(0, event_name,
+  return Send(new AutomationMsg_GetMetricEventDuration(event_name,
                                                        duration_ms));
 }
 
 bool AutomationProxy::SetFilteredInet(bool enabled) {
-  return Send(new AutomationMsg_SetFilteredInet(0, enabled));
+  return Send(new AutomationMsg_SetFilteredInet(enabled));
 }
 
 int AutomationProxy::GetFilteredInetHitCount() {
   int hit_count;
-  if (!Send(new AutomationMsg_GetFilteredInetHitCount(0, &hit_count)))
+  if (!Send(new AutomationMsg_GetFilteredInetHitCount(&hit_count)))
     return -1;
   return hit_count;
 }
 
 bool AutomationProxy::SendProxyConfig(const std::string& new_proxy_config) {
-  return Send(new AutomationMsg_SetProxyConfig(0, new_proxy_config));
+  return Send(new AutomationMsg_SetProxyConfig(new_proxy_config));
 }
 
 void AutomationProxy::Disconnect() {
   DCHECK(shutdown_event_.get() != NULL);
   shutdown_event_->Signal();
   channel_.reset();
 }
 
 void AutomationProxy::OnMessageReceived(const IPC::Message& msg) {
   // This won't get called unless AutomationProxy is run from
   // inside a message loop.
   NOTREACHED();
 }
 
 void AutomationProxy::OnChannelError() {
   LOG(ERROR) << "Channel error in AutomationProxy.";
   if (disconnect_on_failure_)
     Disconnect();
 }
 
 scoped_refptr<WindowProxy> AutomationProxy::GetActiveWindow() {
   int handle = 0;
-  if (!Send(new AutomationMsg_ActiveWindow(0, &handle)))
+  if (!Send(new AutomationMsg_ActiveWindow(&handle)))
     return NULL;
 
   return ProxyObjectFromHandle<WindowProxy>(handle);
 }
 
 scoped_refptr<BrowserProxy> AutomationProxy::GetBrowserWindow(
     int window_index) {
   int handle = 0;
-  if (!Send(new AutomationMsg_BrowserWindow(0, window_index, &handle)))
+  if (!Send(new AutomationMsg_BrowserWindow(window_index, &handle)))
     return NULL;
 
   return ProxyObjectFromHandle<BrowserProxy>(handle);
 }
 
 bool AutomationProxy::GetBrowserLocale(string16* locale) {
   DCHECK(locale != NULL);
-  if (!Send(new AutomationMsg_GetBrowserLocale(0, locale)))
+  if (!Send(new AutomationMsg_GetBrowserLocale(locale)))
     return false;
 
   return !locale->empty();
 }
 
 scoped_refptr<BrowserProxy> AutomationProxy::FindNormalBrowserWindow() {
   int handle = 0;
-  if (!Send(new AutomationMsg_FindNormalBrowserWindow(0, &handle)))
+  if (!Send(new AutomationMsg_FindNormalBrowserWindow(&handle)))
     return NULL;
 
   return ProxyObjectFromHandle<BrowserProxy>(handle);
 }
 
 scoped_refptr<BrowserProxy> AutomationProxy::GetLastActiveBrowserWindow() {
   int handle = 0;
-  if (!Send(new AutomationMsg_LastActiveBrowserWindow(0, &handle)))
+  if (!Send(new AutomationMsg_LastActiveBrowserWindow(&handle)))
     return NULL;
 
   return ProxyObjectFromHandle<BrowserProxy>(handle);
 }
 
 #if defined(OS_POSIX)
 base::file_handle_mapping_vector AutomationProxy::fds_to_map() const {
   base::file_handle_mapping_vector map;
   const int ipcfd = channel_->GetClientFileDescriptor();
   if (ipcfd > -1)
@@ skipping 27 matching lines @@
 void AutomationProxy::InvalidateHandle(const IPC::Message& message) {
   void* iter = NULL;
   int handle;
 
   if (message.ReadInt(&iter, &handle)) {
     tracker_->InvalidateHandle(handle);
   }
 }
 
 bool AutomationProxy::OpenNewBrowserWindow(Browser::Type type, bool show) {
-  if (type == Browser::TYPE_NORMAL)
-    return Send(new AutomationMsg_OpenNewBrowserWindow(0, show));
   return Send(
-      new AutomationMsg_OpenNewBrowserWindowOfType(0, static_cast<int>(type),
+      new AutomationMsg_OpenNewBrowserWindowOfType(static_cast<int>(type),
                                                    show));
 }
 
 scoped_refptr<TabProxy> AutomationProxy::CreateExternalTab(
-    const IPC::ExternalTabSettings& settings,
+    const ExternalTabSettings& settings,
     gfx::NativeWindow* external_tab_container,
     gfx::NativeWindow* tab) {
   int handle = 0;
   int session_id = 0;
   bool succeeded =
-      Send(new AutomationMsg_CreateExternalTab(0, settings,
+      Send(new AutomationMsg_CreateExternalTab(settings,
                                                external_tab_container,
                                                tab,
                                                &handle,
                                                &session_id));
   if (!succeeded) {
     return NULL;
   }
 
 #if defined(OS_WIN)
   DCHECK(IsWindow(*external_tab_container));
@@ skipping 29 matching lines @@
 
 void AutomationProxy::ResetChannel() {
   if (tracker_.get())
     tracker_->put_channel(NULL);
 }
 
 #if defined(OS_CHROMEOS)
 bool AutomationProxy::LoginWithUserAndPass(const std::string& username,
                                            const std::string& password) {
   bool success;
-  bool sent = Send(new AutomationMsg_LoginWithUserAndPass(0, username,
+  bool sent = Send(new AutomationMsg_LoginWithUserAndPass(username,
                                                           password,
                                                           &success));
   // If message sending unsuccessful or test failed, return false.
   return sent && success;
 }
 #endif
 
 bool AutomationProxy::ResetToDefaultTheme() {
-  return Send(new AutomationMsg_ResetToDefaultTheme(0));
+  return Send(new AutomationMsg_ResetToDefaultTheme());
 }