Clean up Automation and Chrome Frame IPC code.

chrome/browser/external_tab_container_win.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/browser/external_tab_container_win.h"
 
 #include <string>
 
 #include "app/l10n_util.h"
 #include "app/view_prop.h"
@@ skipping 326 matching lines @@
 
   switch (disposition) {
     case CURRENT_TAB:
     case SINGLETON_TAB:
     case NEW_FOREGROUND_TAB:
     case NEW_BACKGROUND_TAB:
     case NEW_POPUP:
     case NEW_WINDOW:
     case SAVE_TO_DISK:
       if (automation_) {
-        automation_->Send(new AutomationMsg_OpenURL(0, tab_handle_,
+        automation_->Send(new AutomationMsg_OpenURL(tab_handle_,
                                                     url, referrer,
                                                     disposition));
         // TODO(ananta)
         // We should populate other fields in the
         // ViewHostMsg_FrameNavigate_Params structure. Another option could be
         // to refactor the UpdateHistoryForNavigation function in TabContents.
         ViewHostMsg_FrameNavigate_Params params;
         params.referrer = referrer;
         params.url = url;
         params.page_id = -1;
         params.transition = PageTransition::LINK;
 
         NavigationController::LoadCommittedDetails details;
         details.did_replace_entry = false;
 
         scoped_refptr<history::HistoryAddPageArgs> add_page_args(
             tab_contents_->CreateHistoryAddPageArgs(url, details, params));
         tab_contents_->UpdateHistoryForNavigation(add_page_args);
       }
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
 void ExternalTabContainer::NavigationStateChanged(const TabContents* source,
                                                   unsigned changed_flags) {
   if (automation_) {
-    IPC::NavigationInfo nav_info;
+    NavigationInfo nav_info;
     if (InitNavigationInfo(&nav_info, NavigationType::NAV_IGNORE, 0))
       automation_->Send(new AutomationMsg_NavigationStateChanged(
-          0, tab_handle_, changed_flags, nav_info));
+          tab_handle_, changed_flags, nav_info));
   }
 }
 
 void ExternalTabContainer::AddNewContents(TabContents* source,
                             TabContents* new_contents,
                             WindowOpenDisposition disposition,
                             const gfx::Rect& initial_pos,
                             bool user_gesture) {
   if (!automation_) {
     DCHECK(pending_);
@@ skipping 34 matching lines @@
       true,
       route_all_top_level_navigations_);
 
   if (result) {
     if (route_all_top_level_navigations_) {
       return;
     }
     uintptr_t cookie = reinterpret_cast<uintptr_t>(new_container.get());
     pending_tabs_.Get()[cookie] = new_container;
     new_container->set_pending(true);
-    IPC::AttachExternalTabParams attach_params_;
+    AttachExternalTabParams attach_params_;
     attach_params_.cookie = static_cast<uint64>(cookie);
     attach_params_.dimensions = initial_pos;
     attach_params_.user_gesture = user_gesture;
     attach_params_.disposition = disposition;
     attach_params_.profile_name = WideToUTF8(
         tab_contents()->profile()->GetPath().DirName().BaseName().value());
-    automation_->Send(new AutomationMsg_AttachExternalTab(0,
+    automation_->Send(new AutomationMsg_AttachExternalTab(
         tab_handle_, attach_params_));
   } else {
     NOTREACHED();
   }
 }
 
 void ExternalTabContainer::TabContentsCreated(TabContents* new_contents) {
   RenderViewHost* rvh = new_contents->render_view_host();
   DCHECK(rvh != NULL);
 
@@ skipping 19 matching lines @@
 void ExternalTabContainer::CloseContents(TabContents* source) {
   if (!automation_)
     return;
 
   if (unload_reply_message_) {
     AutomationMsg_RunUnloadHandlers::WriteReplyParams(unload_reply_message_,
                                                       true);
     automation_->Send(unload_reply_message_);
     unload_reply_message_ = NULL;
   } else {
-    automation_->Send(new AutomationMsg_CloseExternalTab(0, tab_handle_));
+    automation_->Send(new AutomationMsg_CloseExternalTab(tab_handle_));
   }
 }
 
 void ExternalTabContainer::MoveContents(TabContents* source,
                                         const gfx::Rect& pos) {
 }
 
 void ExternalTabContainer::URLStarredChanged(TabContents* source,
                                              bool starred) {
 }
 
 void ExternalTabContainer::UpdateTargetURL(TabContents* source,
                                            const GURL& url) {
   if (automation_) {
     std::wstring url_string = CA2W(url.spec().c_str());
     automation_->Send(
-        new AutomationMsg_UpdateTargetUrl(0, tab_handle_, url_string));
+        new AutomationMsg_UpdateTargetUrl(tab_handle_, url_string));
   }
 }
 
 void ExternalTabContainer::ContentsZoomChange(bool zoom_in) {
 }
 
 void ExternalTabContainer::ToolbarSizeChanged(TabContents* source,
                                               bool finished) {
 }
 
 void ExternalTabContainer::ForwardMessageToExternalHost(
     const std::string& message, const std::string& origin,
     const std::string& target) {
   if (automation_) {
-    automation_->Send(
-        new AutomationMsg_ForwardMessageToExternalHost(0, tab_handle_,
-            message, origin, target));
+    automation_->Send(new AutomationMsg_ForwardMessageToExternalHost(
+        tab_handle_, message, origin, target));
   }
 }
 
 bool ExternalTabContainer::IsExternalTabContainer() const {
   return true;
 }
 
 gfx::NativeWindow ExternalTabContainer::GetFrameNativeWindow() {
   return hwnd();
 }
 
 bool ExternalTabContainer::TakeFocus(bool reverse) {
   if (automation_) {
-    automation_->Send(new AutomationMsg_TabbedOut(0, tab_handle_,
+    automation_->Send(new AutomationMsg_TabbedOut(tab_handle_,
         win_util::IsShiftPressed()));
   }
 
   return true;
 }
 
 bool ExternalTabContainer::CanDownload(int request_id) {
   if (load_requests_via_automation_) {
     if (automation_) {
       // In case the host needs to show UI that needs to take the focus.
@@ skipping 74 matching lines @@
   }
   external_context_menu_.reset(
       new RenderViewContextMenuViews(tab_contents(), params));
   external_context_menu_->SetExternal();
   external_context_menu_->Init();
   external_context_menu_->UpdateMenuItemStates();
 
   POINT screen_pt = { params.x, params.y };
   MapWindowPoints(GetNativeView(), HWND_DESKTOP, &screen_pt, 1);
 
-  IPC::MiniContextMenuParams ipc_params(
+  MiniContextMenuParams ipc_params(
       screen_pt.x,
       screen_pt.y,
       params.link_url,
       params.unfiltered_link_url,
       params.src_url,
       params.page_url,
       params.frame_url);
 
   bool rtl = base::i18n::IsRTL();
   automation_->Send(
-      new AutomationMsg_ForwardContextMenuToExternalHost(0, tab_handle_,
+      new AutomationMsg_ForwardContextMenuToExternalHost(tab_handle_,
           external_context_menu_->GetMenuHandle(),
           rtl ? TPM_RIGHTALIGN : TPM_LEFTALIGN, ipc_params));
 
   return true;
 }
 
 bool ExternalTabContainer::ExecuteContextMenuCommand(int command) {
   if (!external_context_menu_.get()) {
     NOTREACHED();
     return false;
@@ skipping 74 matching lines @@
   static const int kHttpClientErrorStart = 400;
   static const int kHttpServerErrorEnd = 510;
 
   switch (type.value) {
     case NotificationType::LOAD_STOP: {
         const LoadNotificationDetails* load =
             Details<LoadNotificationDetails>(details).ptr();
         if (load != NULL && PageTransition::IsMainFrame(load->origin())) {
           TRACE_EVENT_END("ExternalTabContainer::Navigate", 0,
                           load->url().spec());
-          automation_->Send(new AutomationMsg_TabLoaded(0, tab_handle_,
+          automation_->Send(new AutomationMsg_TabLoaded(tab_handle_,
                                                         load->url()));
         }
         break;
       }
     case NotificationType::NAV_ENTRY_COMMITTED: {
         if (ignore_next_load_notification_) {
           ignore_next_load_notification_ = false;
           return;
         }
 
         const NavigationController::LoadCommittedDetails* commit =
             Details<NavigationController::LoadCommittedDetails>(details).ptr();
 
         if (commit->http_status_code >= kHttpClientErrorStart &&
             commit->http_status_code <= kHttpServerErrorEnd) {
           automation_->Send(new AutomationMsg_NavigationFailed(
-              0, tab_handle_, commit->http_status_code, commit->entry->url()));
+              tab_handle_, commit->http_status_code, commit->entry->url()));
 
           ignore_next_load_notification_ = true;
         } else {
-          IPC::NavigationInfo navigation_info;
+          NavigationInfo navigation_info;
           // When the previous entry index is invalid, it will be -1, which
           // will still make the computation come out right (navigating to the
           // 0th entry will be +1).
           if (InitNavigationInfo(&navigation_info, commit->type,
                   commit->previous_entry_index -
                   tab_contents_->controller().last_committed_entry_index()))
-            automation_->Send(new AutomationMsg_DidNavigate(0, tab_handle_,
+            automation_->Send(new AutomationMsg_DidNavigate(tab_handle_,
                                                             navigation_info));
         }
         break;
       }
     case NotificationType::FAIL_PROVISIONAL_LOAD_WITH_ERROR: {
       const ProvisionalLoadDetails* load_details =
           Details<ProvisionalLoadDetails>(details).ptr();
       automation_->Send(new AutomationMsg_NavigationFailed(
-          0, tab_handle_, load_details->error_code(), load_details->url()));
+          tab_handle_, load_details->error_code(), load_details->url()));
 
       ignore_next_load_notification_ = true;
       break;
     }
     case NotificationType::RENDER_VIEW_HOST_CREATED_FOR_TAB: {
       if (load_requests_via_automation_) {
         RenderViewHost* rvh = Details<RenderViewHost>(details).ptr();
         RegisterRenderViewHostForAutomation(rvh, false);
       }
       break;
@@ skipping 74 matching lines @@
 
   // Send this keystroke to the external host as it could be processed as an
   // accelerator there. If the host does not handle this accelerator, it will
   // reflect the accelerator back to us via the ProcessUnhandledAccelerator
   // method.
   MSG msg = {0};
   msg.hwnd = window;
   msg.message = message;
   msg.wParam = wparam;
   msg.lParam = lparam;
-  automation_->Send(new AutomationMsg_HandleAccelerator(0, tab_handle_, msg));
+  automation_->Send(new AutomationMsg_HandleAccelerator(tab_handle_, msg));
   return true;
 }
 
-bool ExternalTabContainer::InitNavigationInfo(IPC::NavigationInfo* nav_info,
+bool ExternalTabContainer::InitNavigationInfo(NavigationInfo* nav_info,
                                               NavigationType::Type nav_type,
                                               int relative_offset) {
   DCHECK(nav_info);
   NavigationEntry* entry = tab_contents_->controller().GetActiveEntry();
   // If this is very early in the game then we may not have an entry.
   if (!entry)
     return false;
 
   nav_info->navigation_type = nav_type;
   nav_info->relative_offset = relative_offset;
@@ skipping 105 matching lines @@
 
   TRACE_EVENT_BEGIN("ExternalTabContainer::Navigate", 0, url.spec());
 
   tab_contents_->controller().LoadURL(url, referrer,
                                       PageTransition::START_PAGE);
 }
 
 bool ExternalTabContainer::OnGoToEntryOffset(int offset) {
   if (load_requests_via_automation_) {
     automation_->Send(new AutomationMsg_RequestGoToHistoryEntryOffset(
-        0, tab_handle_, offset));
+        tab_handle_, offset));
     return false;
   }
 
   return true;
 }
 
 void ExternalTabContainer::LoadAccelerators() {
   HACCEL accelerator_table = AtlLoadAccelerators(IDR_CHROMEFRAME);
   DCHECK(accelerator_table);
 
@@ skipping 109 matching lines @@
 
   if (disposition == CURRENT_TAB) {
     DCHECK(route_all_top_level_navigations_);
     disposition = NEW_FOREGROUND_TAB;
   }
   ExternalTabContainer::OpenURLFromTab(source, url, referrer, disposition,
                                        transition);
   // support only one navigation for a dummy tab before it is killed.
   ::DestroyWindow(GetNativeView());
 }