Clean up Automation and Chrome Frame IPC code.

chrome_frame/external_tab.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/external_tab.h"
 #include "base/lazy_instance.h"
 #include "base/tracked.h"
 #include "base/task.h"
 #include "base/waitable_event.h"
 #include "chrome/common/automation_messages.h"
@@ skipping 16 matching lines @@
 
 ExternalTabProxy::ExternalTabProxy() : state_(NONE), tab_(0), tab_wnd_(NULL),
     chrome_wnd_(NULL), proxy_factory_(g_proxy_factory.Pointer()), proxy_(NULL),
     ui_delegate_(NULL) {
 }
 
 ExternalTabProxy::~ExternalTabProxy() {
   Destroy();
 }
 
+void ExternalTabProxy::OnMessageReceived(const IPC::Message& message) {
+  IPC_BEGIN_MESSAGE_MAP(ExternalTabProxy, message)
+    IPC_MESSAGE_HANDLER(AutomationMsg_NavigationStateChanged,
+                        OnNavigationStateChanged)
+    IPC_MESSAGE_HANDLER(AutomationMsg_UpdateTargetUrl, OnUpdateTargetUrl)
+    IPC_MESSAGE_HANDLER(AutomationMsg_HandleAccelerator, OnHandleAccelerator)
+    IPC_MESSAGE_HANDLER(AutomationMsg_TabbedOut, OnTabbedOut)
+    IPC_MESSAGE_HANDLER(AutomationMsg_OpenURL, OnOpenURL)
+    IPC_MESSAGE_HANDLER(AutomationMsg_NavigationFailed, OnNavigationFailed)
+    IPC_MESSAGE_HANDLER(AutomationMsg_DidNavigate, OnDidNavigate)
+    IPC_MESSAGE_HANDLER(AutomationMsg_TabLoaded, OnTabLoaded)
+    IPC_MESSAGE_HANDLER(AutomationMsg_ForwardMessageToExternalHost,
+                        OnMessageToHost)
+    IPC_MESSAGE_HANDLER(AutomationMsg_ForwardContextMenuToExternalHost,
+                        OnHandleContextMenu)
+    IPC_MESSAGE_HANDLER(AutomationMsg_RequestStart, OnNetwork_Start)
+    IPC_MESSAGE_HANDLER(AutomationMsg_RequestRead, OnNetwork_Read)
+    IPC_MESSAGE_HANDLER(AutomationMsg_RequestEnd, OnNetwork_End)
+    IPC_MESSAGE_HANDLER(AutomationMsg_DownloadRequestInHost,
+                        OnNetwork_DownloadInHost)
+    IPC_MESSAGE_HANDLER(AutomationMsg_GetCookiesFromHost, OnGetCookies)
+    IPC_MESSAGE_HANDLER(AutomationMsg_SetCookieAsync, OnSetCookie)
+    IPC_MESSAGE_HANDLER(AutomationMsg_AttachExternalTab, OnAttachTab)
+    IPC_MESSAGE_HANDLER(AutomationMsg_RequestGoToHistoryEntryOffset,
+                        OnGoToHistoryOffset)
+    IPC_MESSAGE_HANDLER(AutomationMsg_CloseExternalTab, OnTabClosed)
+  IPC_END_MESSAGE_MAP()
+}
+
 void ExternalTabProxy::Init() {
   if (m_hWnd == NULL) {
     // Create a window on the UI thread for marshaling messages back and forth
     // from the IPC thread. This window cannot be a message only window as the
     // external chrome tab window initially is created as a child of this window
     CWindowImpl<ExternalTabProxy>::Create(GetDesktopWindow(), NULL, NULL,
         WS_CHILDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS, WS_EX_TOOLWINDOW);
     DCHECK(m_hWnd != NULL);
     ui_.SetWindow(m_hWnd, WM_APP + 6);
   }
@@ skipping 34 matching lines @@
 }
 
 void ExternalTabProxy::Connected(ChromeProxy* proxy) {
   // in ipc thread
   ui_.PostTask(FROM_HERE, NewRunnableMethod(this,
       &ExternalTabProxy::UiConnected, proxy));
 }
 
 void ExternalTabProxy::UiConnected(ChromeProxy* proxy) {
   proxy_ = proxy;
-  IPC::ExternalTabSettings settings;
+  ExternalTabSettings settings;
   settings.parent = m_hWnd;
   settings.style = WS_CHILD;
   settings.is_off_the_record = tab_params_.is_incognito;
   // TODO(stoyan): FIX this.
   settings.load_requests_via_automation = true;
   // TODO(stoyan): FIX this.
   settings.handle_top_level_requests = true;
   settings.initial_url = tab_params_.url;
   settings.referrer = tab_params_.referrer;
   // Infobars are disabled in widget mode.
@@ skipping 113 matching lines @@
 
 void ExternalTabProxy::Completed_CreateTab(bool success, HWND chrome_wnd,
                                            HWND tab_window, int tab_handle,
                                            int session_id) {
   // in ipc_thread.
   ui_.PostTask(FROM_HERE, NewRunnableMethod(this,
       &ExternalTabProxy::UiCompleted_CreateTab,
       success, chrome_wnd, tab_window, tab_handle, session_id));
 }
 
-void ExternalTabProxy::Completed_ConnectToTab(bool success,
-    HWND chrome_window, HWND tab_window, int tab_handle, int session_id) {
+void ExternalTabProxy::Completed_ConnectToTab(
+    bool success, HWND chrome_window, HWND tab_window, int tab_handle,
+    int session_id) {
   CHECK(0);
 }
 
-void ExternalTabProxy::Completed_Navigate(bool success,
-    enum AutomationMsg_NavigationResponseValues res) {
+void ExternalTabProxy::Completed_Navigate(
+    bool success, enum AutomationMsg_NavigationResponseValues res) {
   // ipc_thread;
   CHECK(0);
 }
 
-void ExternalTabProxy::Completed_InstallExtension(bool success,
-    enum AutomationMsg_ExtensionResponseValues res, SyncMessageContext* ctx) {
+void ExternalTabProxy::Completed_InstallExtension(
+    bool success, enum AutomationMsg_ExtensionResponseValues res,
+    SyncMessageContext* ctx) {
   CHECK(0);
 }
 
-void ExternalTabProxy::Completed_LoadExpandedExtension(bool success,
-    enum AutomationMsg_ExtensionResponseValues res, SyncMessageContext* ctx) {
+void ExternalTabProxy::Completed_LoadExpandedExtension(
+    bool success, enum AutomationMsg_ExtensionResponseValues res,
+    SyncMessageContext* ctx) {
   CHECK(0);
 }
 
-void ExternalTabProxy::Completed_GetEnabledExtensions(bool success,
-    const std::vector<FilePath>* extensions) {
+void ExternalTabProxy::Completed_GetEnabledExtensions(
+    bool success, const std::vector<FilePath>* extensions) {
   CHECK(0);
 }
 
-void ExternalTabProxy::NavigationStateChanged(int flags,
-    const IPC::NavigationInfo& nav_info) {
+void ExternalTabProxy::OnNavigationStateChanged(
+    int flags, const NavigationInfo& nav_info) {
   ui_.PostTask(FROM_HERE, NewRunnableMethod(ui_delegate_,
       &UIDelegate::OnNavigationStateChanged, flags, nav_info));
 }
 
-void ExternalTabProxy::UpdateTargetUrl(const std::wstring& url) {
+void ExternalTabProxy::OnUpdateTargetUrl(const std::wstring& url) {
   ui_.PostTask(FROM_HERE, NewRunnableMethod(ui_delegate_,
       &UIDelegate::OnUpdateTargetUrl, url));
 }
 
-void ExternalTabProxy::TabLoaded(const GURL& url) {
+void ExternalTabProxy::OnTabLoaded(const GURL& url) {
   ui_.PostTask(FROM_HERE, NewRunnableMethod(ui_delegate_,
       &UIDelegate::OnLoad, url));
 }
 
-void ExternalTabProxy::MessageToHost(const std::string& message,
-                                     const std::string& origin,
-                                     const std::string& target) {
+void ExternalTabProxy::OnMessageToHost(const std::string& message,
+                                       const std::string& origin,
+                                       const std::string& target) {
   ui_.PostTask(FROM_HERE, NewRunnableMethod(ui_delegate_,
       &UIDelegate::OnMessageFromChromeFrame, message, origin, target));
 }
 
-void ExternalTabProxy::HandleAccelerator(const MSG& accel_message) {
+void ExternalTabProxy::OnHandleAccelerator(const MSG& accel_message) {
   ui_.PostTask(FROM_HERE, NewRunnableMethod(ui_delegate_,
       &UIDelegate::OnHandleAccelerator, accel_message));
 }
 
-void ExternalTabProxy::HandleContextMenu(
+void ExternalTabProxy::OnHandleContextMenu(
     HANDLE menu_handle,
     int align_flags,
-    const IPC::MiniContextMenuParams& params) {
+    const MiniContextMenuParams& params) {
   ui_.PostTask(FROM_HERE, NewRunnableMethod(ui_delegate_,
       &UIDelegate::OnHandleContextMenu, menu_handle, align_flags, params));
 }
 
-void ExternalTabProxy::TabbedOut(bool reverse) {
+void ExternalTabProxy::OnTabbedOut(bool reverse) {
   ui_.PostTask(FROM_HERE, NewRunnableMethod(ui_delegate_,
       &UIDelegate::OnTabbedOut, reverse));
 }
 
-void ExternalTabProxy::GoToHistoryOffset(int offset) {
+void ExternalTabProxy::OnGoToHistoryOffset(int offset) {
   ui_.PostTask(FROM_HERE, NewRunnableMethod(ui_delegate_,
       &UIDelegate::OnGoToHistoryOffset, offset));
 }
 
-void ExternalTabProxy::OpenURL(const GURL& url_to_open, const GURL& referrer,
-                               int open_disposition) {
+void ExternalTabProxy::OnOpenURL(const GURL& url_to_open, const GURL& referrer,
+                                 int open_disposition) {
   ui_.PostTask(FROM_HERE, NewRunnableMethod(ui_delegate_,
       &UIDelegate::OnOpenURL, url_to_open, referrer, open_disposition));
 }
 
-void ExternalTabProxy::NavigationFailed(int error_code, const GURL& gurl) {
+void ExternalTabProxy::OnNavigationFailed(int error_code, const GURL& gurl) {
   // TODO(stoyan):
 }
 
-void ExternalTabProxy::DidNavigate(const IPC::NavigationInfo& navigation_info) {
+void ExternalTabProxy::OnDidNavigate(const NavigationInfo& navigation_info) {
   // TODO(stoyan):
 }
 
-void ExternalTabProxy::Network_Start(
-    int request_id, const IPC::AutomationURLRequest& request_info) {
+void ExternalTabProxy::OnNetwork_Start(
+    int request_id, const AutomationURLRequest& request_info) {
   // TODO(stoyan): url_fetcher_.Start();
 }
 
-void ExternalTabProxy::Network_Read(int request_id, int bytes_to_read) {
+void ExternalTabProxy::OnNetwork_Read(int request_id, int bytes_to_read) {
   // TODO(stoyan): url_fetcher_.Read();
 }
 
-void ExternalTabProxy::Network_End(int request_id, const URLRequestStatus& s) {
+void ExternalTabProxy::OnNetwork_End(int request_id,
+                                     const URLRequestStatus& s) {
   // TODO(stoyan):
 }
 
-void ExternalTabProxy::Network_DownloadInHost(int request_id) {
+void ExternalTabProxy::OnNetwork_DownloadInHost(int request_id) {
   // TODO(stoyan):
 }
 
-void ExternalTabProxy::GetCookies(const GURL& url, int cookie_id) {
+void ExternalTabProxy::OnGetCookies(const GURL& url, int cookie_id) {
   // TODO(stoyan):
 }
 
-void ExternalTabProxy::SetCookie(const GURL& url, const std::string& cookie) {
+void ExternalTabProxy::OnSetCookie(const GURL& url, const std::string& cookie) {
   // TODO(stoyan):
 }
 
-void ExternalTabProxy::TabClosed() {
+void ExternalTabProxy::OnTabClosed() {
   // TODO(stoyan):
 }
 
-void ExternalTabProxy::AttachTab(
-    const IPC::AttachExternalTabParams& attach_params) {
+void ExternalTabProxy::OnAttachTab(
+    const AttachExternalTabParams& attach_params) {
   // TODO(stoyan):
 }