Clean up Automation and Chrome Frame IPC code.

chrome_frame/chrome_frame_automation.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_frame/chrome_frame_automation.h"
 
 #include "app/app_switches.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
@@ skipping 49 matching lines @@
 
   void RemoveTabProxy(AutomationHandle tab_proxy) {
     AutoLock lock(lock_);
     tabs_list_.remove(tab_proxy);
   }
 
   virtual bool OnMessageReceived(const IPC::Message& message) {
     if (message.is_reply())
       return false;
 
-    int tab_handle = 0;
-    if (!ChromeFrameDelegateImpl::IsTabMessage(message, &tab_handle))
+    if (!ChromeFrameDelegateImpl::IsTabMessage(message))
       return false;
 
     // Get AddRef-ed pointer to corresponding TabProxy object
-    TabProxy* tab = static_cast<TabProxy*>(tracker_->GetResource(tab_handle));
+    TabProxy* tab = static_cast<TabProxy*>(tracker_->GetResource(
+        message.routing_id()));
     if (tab) {
       tab->OnMessageReceived(message);
       tab->Release();
     } else {
-      DLOG(ERROR) << "Failed to find TabProxy for tab:" << tab_handle;
+      DLOG(ERROR) << "Failed to find TabProxy for tab:" << message.routing_id();
     }
     return true;
   }
 
   virtual void OnChannelError() {
     std::list<AutomationHandle>::const_iterator iter = tabs_list_.begin();
     for (; iter != tabs_list_.end(); ++iter) {
       // Get AddRef-ed pointer to corresponding TabProxy object
       TabProxy* tab = static_cast<TabProxy*>(tracker_->GetResource(*iter));
       if (tab) {
@@ skipping 344 matching lines @@
     return;
   }
 
   if (!proxy_.get()) {
     DLOG(WARNING) << __FUNCTION__ << " NULL proxy, can't send UMA data";
   } else {
     ChromeFrameHistogramSnapshots::HistogramPickledList histograms =
         snapshots_->GatherAllHistograms();
 
     if (!histograms.empty()) {
-      proxy_->Send(new AutomationMsg_RecordHistograms(0, histograms));
+      proxy_->Send(new AutomationMsg_RecordHistograms(histograms));
     }
 
     MessageLoop::current()->PostDelayedTask(FROM_HERE,
         NewRunnableMethod(this, &AutomationProxyCacheEntry::SendUMAData),
         uma_send_interval_);
   }
 }
 
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(ProxyFactory);
@@ skipping 294 matching lines @@
 
 bool ChromeFrameAutomationClient::NavigateToIndex(int index) {
   // Could be NULL if we failed to launch Chrome in LaunchAutomationServer()
   if (!automation_server_ || !tab_.get() || !tab_->is_valid()) {
     return false;
   }
 
   DCHECK(::IsWindow(chrome_window_));
 
   IPC::SyncMessage* msg = new AutomationMsg_NavigateExternalTabAtIndex(
-      0, tab_->handle(), index, NULL);
+      tab_->handle(), index, NULL);
   automation_server_->SendAsAsync(msg, new BeginNavigateContext(this),
                                   this);
   return true;
 }
 
 bool ChromeFrameAutomationClient::ForwardMessageFromExternalHost(
     const std::string& message, const std::string& origin,
     const std::string& target) {
   // Could be NULL if we failed to launch Chrome in LaunchAutomationServer()
   if (!is_initialized())
@@ skipping 21 matching lines @@
   }
 
   DCHECK(::IsWindow(chrome_window_));
 
   if (!tab_->is_valid()) {
     DLOG(WARNING) << "BeginNavigate - tab isn't valid.";
     return;
   }
 
   IPC::SyncMessage* msg =
-      new AutomationMsg_NavigateInExternalTab(0, tab_->handle(),
+      new AutomationMsg_NavigateInExternalTab(tab_->handle(),
           chrome_launch_params_->url(), chrome_launch_params_->referrer(),
           NULL);
   automation_server_->SendAsAsync(msg, new BeginNavigateContext(this), this);
 
   RECT client_rect = {0};
   chrome_frame_delegate_->GetBounds(&client_rect);
   Resize(client_rect.right - client_rect.left,
          client_rect.bottom - client_rect.top,
          SWP_NOACTIVATE | SWP_NOZORDER);
 }
@@ skipping 15 matching lines @@
   // the SyncMessageReplyDispatcher to avoid concerns about blocking
   // synchronous messages.
   AutomationMsg_Find_Params params;
   params.unused = 0;
   params.search_string = WideToUTF16Hack(search_string);
   params.find_next = find_next;
   params.match_case = (match_case == CASE_SENSITIVE);
   params.forward = (forward == FWD);
 
   IPC::SyncMessage* msg =
-      new AutomationMsg_Find(0, tab_->handle(), params, NULL, NULL);
+      new AutomationMsg_Find(tab_->handle(), params, NULL, NULL);
   automation_server_->SendAsAsync(msg, NULL, this);
 }
 
 void ChromeFrameAutomationClient::InstallExtension(
     const FilePath& crx_path,
     void* user_data) {
   if (automation_server_ == NULL) {
     InstallExtensionComplete(crx_path,
                              user_data,
                              AUTOMATION_MSG_EXTENSION_INSTALL_FAILED);
     return;
   }
 
   InstallExtensionContext* ctx = new InstallExtensionContext(
       this, crx_path, user_data);
 
-  IPC::SyncMessage* msg =
-      new AutomationMsg_InstallExtension(0, crx_path, NULL);
+  IPC::SyncMessage* msg = new AutomationMsg_InstallExtension(crx_path, NULL);
 
   // The context will delete itself after it is called.
   automation_server_->SendAsAsync(msg, ctx, this);
 }
 
 void ChromeFrameAutomationClient::InstallExtensionComplete(
     const FilePath& crx_path,
     void* user_data,
     AutomationMsg_ExtensionResponseValues res) {
   DCHECK_EQ(PlatformThread::CurrentId(), ui_thread_id_);
 
   if (chrome_frame_delegate_) {
     chrome_frame_delegate_->OnExtensionInstalled(crx_path, user_data, res);
   }
 }
 
 void ChromeFrameAutomationClient::GetEnabledExtensions(void* user_data) {
     if (automation_server_ == NULL) {
       GetEnabledExtensionsComplete(user_data, &std::vector<FilePath>());
       return;
     }
 
     GetEnabledExtensionsContext* ctx = new GetEnabledExtensionsContext(
         this, user_data);
 
     IPC::SyncMessage* msg = new AutomationMsg_GetEnabledExtensions(
-        0, ctx->extension_directories());
+        ctx->extension_directories());
 
     // The context will delete itself after it is called.
     automation_server_->SendAsAsync(msg, ctx, this);
 }
 
 void ChromeFrameAutomationClient::GetEnabledExtensionsComplete(
     void* user_data,
     std::vector<FilePath>* extension_directories) {
   DCHECK_EQ(PlatformThread::CurrentId(), ui_thread_id_);
 
@@ skipping 26 matching lines @@
   if (automation_server_ == NULL) {
     InstallExtensionComplete(path,
                              user_data,
                              AUTOMATION_MSG_EXTENSION_INSTALL_FAILED);
     return;
   }
 
   InstallExtensionContext* ctx = new InstallExtensionContext(
       this, path, user_data);
 
-  IPC::SyncMessage* msg =
-      new AutomationMsg_LoadExpandedExtension(0, path, NULL);
+  IPC::SyncMessage* msg = new AutomationMsg_LoadExpandedExtension(path, NULL);
 
   // The context will delete itself after it is called.
   automation_server_->SendAsAsync(msg, ctx, this);
 }
 
 void ChromeFrameAutomationClient::CreateExternalTab() {
   AutomationLaunchResult launch_result = AUTOMATION_SUCCESS;
   DCHECK(IsWindow());
   DCHECK(automation_server_ != NULL);
 
   if (chrome_launch_params_->url().is_valid()) {
     navigate_after_initialization_ = false;
   }
 
-  const IPC::ExternalTabSettings settings(
+  const ExternalTabSettings settings(
       m_hWnd,
       gfx::Rect(),
       WS_CHILD,
       chrome_launch_params_->incognito(),
       !use_chrome_network_,
       handle_top_level_requests_,
       chrome_launch_params_->url(),
       chrome_launch_params_->referrer(),
       // Infobars disabled in widget mode.
       !chrome_launch_params_->widget_mode(),
       chrome_launch_params_->route_all_top_level_navigations());
 
   THREAD_SAFE_UMA_HISTOGRAM_CUSTOM_COUNTS(
       "ChromeFrame.HostNetworking", !use_chrome_network_, 0, 1, 2);
 
   THREAD_SAFE_UMA_HISTOGRAM_CUSTOM_COUNTS(
       "ChromeFrame.HandleTopLevelRequests", handle_top_level_requests_, 0, 1,
       2);
 
   IPC::SyncMessage* message =
-      new AutomationMsg_CreateExternalTab(0, settings, NULL, NULL, 0, 0);
+      new AutomationMsg_CreateExternalTab(settings, NULL, NULL, 0, 0);
   automation_server_->SendAsAsync(message, new CreateExternalTabContext(this),
                                   this);
 }
 
 AutomationLaunchResult ChromeFrameAutomationClient::CreateExternalTabComplete(
     HWND chrome_window, HWND tab_window, int tab_handle, int session_id) {
   if (!automation_server_) {
     // If we receive this notification while shutting down, do nothing.
     DLOG(ERROR) << "CreateExternalTabComplete called when automation server "
                 << "was null!";
@@ skipping 48 matching lines @@
       // If we have a valid tab_handle here it means that we are attaching to
       // an existing ExternalTabContainer instance, in which case we don't
       // want to create an external tab instance in Chrome.
       if (external_tab_cookie_ == 0) {
         // Continue with Initialization - Create external tab
         CreateExternalTab();
       } else {
         // Send a notification to Chrome that we are ready to connect to the
         // ExternalTab.
         IPC::SyncMessage* message =
-            new AutomationMsg_ConnectExternalTab(0, external_tab_cookie_, true,
+            new AutomationMsg_ConnectExternalTab(external_tab_cookie_, true,
               m_hWnd, NULL, NULL, NULL, 0);
         automation_server_->SendAsAsync(message,
                                         new CreateExternalTabContext(this),
                                         this);
         DVLOG(1) << __FUNCTION__ << ": sending CreateExternalTabComplete";
       }
     }
   } else {
     // Launch failed. Note, we cannot delete proxy here.
     PostTask(FROM_HERE, NewRunnableMethod(this,
@@ skipping 315 matching lines @@
     uint64 external_tab_cookie) {
   DCHECK_EQ(static_cast<TabProxy*>(NULL), tab_.get());
   DCHECK_EQ(-1, tab_handle_);
 
   external_tab_cookie_ = external_tab_cookie;
 }
 
 void ChromeFrameAutomationClient::BlockExternalTab(uint64 cookie) {
   // The host does not want this tab to be shown (due popup blocker).
   IPC::SyncMessage* message =
-      new AutomationMsg_ConnectExternalTab(0, cookie, false, m_hWnd,
+      new AutomationMsg_ConnectExternalTab(cookie, false, m_hWnd,
                                            NULL, NULL, NULL, 0);
   automation_server_->SendAsAsync(message, NULL, this);
 }
 
 void ChromeFrameAutomationClient::SetPageFontSize(
     enum AutomationPageFontSize font_size) {
   if (font_size < SMALLEST_FONT ||
       font_size > LARGEST_FONT) {
       NOTREACHED() << "Invalid font size specified : "
                    << font_size;
       return;
   }
 
   automation_server_->Send(
-      new AutomationMsg_SetPageFontSize(0, tab_handle_, font_size));
+      new AutomationMsg_SetPageFontSize(tab_handle_, font_size));
 }
 
 void ChromeFrameAutomationClient::RemoveBrowsingData(int remove_mask) {
-  automation_server_->Send(
-      new AutomationMsg_RemoveBrowsingData(0, remove_mask));
+  automation_server_->Send(new AutomationMsg_RemoveBrowsingData(remove_mask));
 }
 
 void ChromeFrameAutomationClient::SetUrlFetcher(
     PluginUrlRequestManager* url_fetcher) {
   DCHECK(url_fetcher != NULL);
   url_fetcher_ = url_fetcher;
   url_fetcher_flags_ = url_fetcher->GetThreadSafeFlags();
   url_fetcher_->set_delegate(this);
 }
 
 void ChromeFrameAutomationClient::SetZoomLevel(PageZoom::Function zoom_level) {
   if (automation_server_) {
-    automation_server_->Send(new AutomationMsg_SetZoomLevel(0, tab_handle_,
+    automation_server_->Send(new AutomationMsg_SetZoomLevel(tab_handle_,
                                                             zoom_level));
   }
 }
 
 void ChromeFrameAutomationClient::OnUnload(bool* should_unload) {
   *should_unload = true;
   if (automation_server_) {
     const DWORD kUnloadEventTimeout = 20000;
 
-    IPC::SyncMessage* msg = new AutomationMsg_RunUnloadHandlers(0, tab_handle_,
+    IPC::SyncMessage* msg = new AutomationMsg_RunUnloadHandlers(tab_handle_,
                                                                 should_unload);
     base::WaitableEvent unload_call_finished(false, false);
     UnloadContext* unload_context = new UnloadContext(&unload_call_finished,
                                                       should_unload);
     automation_server_->SendAsAsync(msg, unload_context, this);
     HANDLE done = unload_call_finished.handle();
     WaitWithMessageLoop(&done, 1, kUnloadEventTimeout);
   }
 }
 
 //////////////////////////////////////////////////////////////////////////
 // PluginUrlRequestDelegate implementation.
 // Forward network related responses to Chrome.
 
 void ChromeFrameAutomationClient::OnResponseStarted(int request_id,
     const char* mime_type,  const char* headers, int size,
     base::Time last_modified, const std::string& redirect_url,
     int redirect_status) {
-  const IPC::AutomationURLResponse response(
+  const AutomationURLResponse response(
       mime_type,
       headers ? headers : "",
       size,
       last_modified,
       redirect_url,
       redirect_status);
 
-  automation_server_->Send(new AutomationMsg_RequestStarted(0,
+  automation_server_->Send(new AutomationMsg_RequestStarted(
       tab_->handle(), request_id, response));
 }
 
 void ChromeFrameAutomationClient::OnReadComplete(int request_id,
                                                  const std::string& data) {
-  automation_server_->Send(new AutomationMsg_RequestData(0, tab_->handle(),
-      request_id, data));
+  automation_server_->Send(new AutomationMsg_RequestData(
+      tab_->handle(), request_id, data));
 }
 
 void ChromeFrameAutomationClient::OnResponseEnd(int request_id,
     const URLRequestStatus& status) {
-  automation_server_->Send(new AutomationMsg_RequestEnd(0, tab_->handle(),
-      request_id, status));
+  automation_server_->Send(new AutomationMsg_RequestEnd(
+      tab_->handle(), request_id, status));
 }
 
 void ChromeFrameAutomationClient::OnCookiesRetrieved(bool success,
     const GURL& url, const std::string& cookie_string, int cookie_id) {
-  automation_server_->Send(new AutomationMsg_GetCookiesHostResponse(0,
+  automation_server_->Send(new AutomationMsg_GetCookiesHostResponse(
       tab_->handle(), success, url, cookie_string, cookie_id));
 }