Clean up Automation and Chrome Frame IPC code.

chrome_frame/chrome_frame_activex_base.h

 // 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.
 
 #ifndef CHROME_FRAME_CHROME_FRAME_ACTIVEX_BASE_H_
 #define CHROME_FRAME_CHROME_FRAME_ACTIVEX_BASE_H_
 
 #include <atlbase.h>
 #include <atlcom.h>
 #include <atlctl.h>
@@ skipping 331 matching lines @@
       doc_site_.QueryFrom(client_site);
     }
 
     if (client_site == NULL) {
       in_place_frame_.Release();
     }
 
     return CComControlBase::IOleObject_SetClientSite(client_site);
   }
 
-  bool HandleContextMenuCommand(UINT cmd,
-                                const IPC::MiniContextMenuParams& params) {
+  bool HandleContextMenuCommand(UINT cmd, const MiniContextMenuParams& params) {
     if (cmd == IDC_ABOUT_CHROME_FRAME) {
       int tab_handle = automation_client_->tab()->handle();
       HostNavigate(GURL("about:version"), GURL(), NEW_WINDOW);
       return true;
     } else {
       switch (cmd) {
         case IDS_CONTENT_CONTEXT_SAVEAUDIOAS:
         case IDS_CONTENT_CONTEXT_SAVEVIDEOAS:
         case IDS_CONTENT_CONTEXT_SAVEIMAGEAS:
         case IDS_CONTENT_CONTEXT_SAVELINKAS: {
@@ skipping 44 matching lines @@
     // after CF is first loaded.
     if (is_IE && GetIEVersion() < IE_8 && !ceee_util::IsIeCeeeRegistered()) {
       *profile_path = GetIETemporaryFilesFolder();
       *profile_path = profile_path->Append(L"Google Chrome Frame");
     } else {
       ChromeFramePlugin::GetProfilePath(profile_name, profile_path);
     }
     DVLOG(1) << __FUNCTION__ << ": " << profile_path->value();
   }
 
-  void OnLoad(int tab_handle, const GURL& url) {
+  void OnLoad(const GURL& url) {
     if (ready_state_ < READYSTATE_COMPLETE) {
       ready_state_ = READYSTATE_COMPLETE;
       FireOnChanged(DISPID_READYSTATE);
     }
 
     HRESULT hr = InvokeScriptFunction(onload_handler_, url.spec());
   }
 
   void OnLoadFailed(int error_code, const std::string& url) {
     HRESULT hr = InvokeScriptFunction(onerror_handler_, url);
   }
 
-  void OnMessageFromChromeFrame(int tab_handle, const std::string& message,
+  void OnMessageFromChromeFrame(const std::string& message,
                                 const std::string& origin,
                                 const std::string& target) {
     base::win::ScopedComPtr<IDispatch> message_event;
     if (SUCCEEDED(CreateDomEvent("message", message, origin,
                                  message_event.Receive()))) {
       base::win::ScopedVariant event_var;
       event_var.Set(static_cast<IDispatch*>(message_event));
       InvokeScriptFunction(onmessage_handler_, event_var.AsInput());
     }
   }
 
-  virtual void OnTabbedOut(int tab_handle, bool reverse) {
+  virtual void OnTabbedOut(bool reverse) {
     DCHECK(m_bInPlaceActive);
 
     HWND parent = ::GetParent(m_hWnd);
     ::SetFocus(parent);
     base::win::ScopedComPtr<IOleControlSite> control_site;
     control_site.QueryFrom(m_spClientSite);
     if (control_site)
       control_site->OnFocus(FALSE);
   }
 
-  virtual void OnOpenURL(int tab_handle, const GURL& url_to_open,
+  virtual void OnOpenURL(const GURL& url_to_open,
                          const GURL& referrer, int open_disposition) {
     HostNavigate(url_to_open, referrer, open_disposition);
   }
 
   // Called when Chrome has decided that a request needs to be treated as a
   // download.  The caller will be the UrlRequest worker thread.
   // The worker thread will block while we process the request and take
   // ownership of the request object.
   // There's room for improvement here and also see todo below.
   LPARAM OnDownloadRequestInHost(UINT message, WPARAM wparam, LPARAM lparam,
                                  BOOL& handled) {
     base::win::ScopedComPtr<IMoniker> moniker(
         reinterpret_cast<IMoniker*>(lparam));
     DCHECK(moniker);
     base::win::ScopedComPtr<IBindCtx> bind_context(
         reinterpret_cast<IBindCtx*>(wparam));
 
     // TODO(tommi): It looks like we might have to switch the request object
     // into a pass-through request object and serve up any thus far received
     // content and headers to IE in order to prevent what can currently happen
     // which is reissuing requests and turning POST into GET.
     if (moniker) {
       NavigateBrowserToMoniker(doc_site_, moniker, NULL, bind_context, NULL);
     }
 
     return TRUE;
   }
 
-  virtual void OnAttachExternalTab(int tab_handle,
-      const IPC::AttachExternalTabParams& params) {
+  virtual void OnAttachExternalTab(const AttachExternalTabParams& params) {
     std::wstring wide_url = url_;
     GURL parsed_url(WideToUTF8(wide_url));
 
     // If Chrome-Frame is presently navigated to an extension page, navigating
     // the host to a url with scheme chrome-extension will fail, so we
     // point the host at http:local_host.  Note that this is NOT the URL
     // to which the host is directed.  It is only used as a temporary message
     // passing mechanism between this CF instance, and the BHO that will
     // be constructed in the new IE tab.
     if (parsed_url.SchemeIs("chrome-extension") &&
@@ skipping 13 matching lines @@
         params.cookie,
         params.disposition,
         params.dimensions.x(),
         params.dimensions.y(),
         params.dimensions.width(),
         params.dimensions.height(),
         params.profile_name.c_str());
     HostNavigate(GURL(url), GURL(), params.disposition);
   }
 
-  virtual void OnHandleContextMenu(int tab_handle, HANDLE menu_handle,
+  virtual void OnHandleContextMenu(HANDLE menu_handle,
                                    int align_flags,
-                                   const IPC::MiniContextMenuParams& params) {
+                                   const MiniContextMenuParams& params) {
     scoped_refptr<BasePlugin> ref(this);
-    ChromeFramePlugin<T>::OnHandleContextMenu(tab_handle, menu_handle,
-                                              align_flags, params);
+    ChromeFramePlugin<T>::OnHandleContextMenu(menu_handle, align_flags, params);
   }
 
   LRESULT OnCreate(UINT message, WPARAM wparam, LPARAM lparam,
                    BOOL& handled) {  // NO_LINT
     ModifyStyle(0, WS_CLIPCHILDREN | WS_CLIPSIBLINGS, 0);
     url_fetcher_->put_notification_window(m_hWnd);
     if (automation_client_.get()) {
       automation_client_->SetParentWindow(m_hWnd);
     } else {
       NOTREACHED() << "No automation server";
@@ skipping 26 matching lines @@
   virtual void OnAutomationServerLaunchFailed(
       AutomationLaunchResult reason, const std::string& server_version) {
     DVLOG(1) << __FUNCTION__;
     if (reason == AUTOMATION_SERVER_CRASHED)
       draw_sad_tab_ = true;
 
     ready_state_ = READYSTATE_UNINITIALIZED;
     FireOnChanged(DISPID_READYSTATE);
   }
 
-  virtual void OnCloseTab(int tab_handle) {
+  virtual void OnCloseTab() {
     Fire_onclose();
   }
 
   // Overridden to take advantage of readystate prop changes and send those
   // to potential listeners.
   HRESULT FireOnChanged(DISPID dispid) {
     if (dispid == DISPID_READYSTATE) {
       Fire_onreadystatechanged(ready_state_);
     }
     return __super::FireOnChanged(dispid);
@@ skipping 505 matching lines @@
       // is very simple.  Just post the message to our parent window and IE
       // will pick it up if it's an accelerator. We won't know for sure if
       // the browser handled the keystroke or not.
       ::PostMessage(accel_message.hwnd, accel_message.message,
                     accel_message.wParam, accel_message.lParam);
     }
 
     return hr;
   }
 
-  virtual void OnAcceleratorPressed(int tab_handle, const MSG& accel_message) {
+  virtual void OnAcceleratorPressed(const MSG& accel_message) {
     DCHECK(m_spInPlaceSite != NULL);
     // Allow our host a chance to handle the accelerator.
     // This catches things like Ctrl+F, Ctrl+O etc, but not browser
     // accelerators such as F11, Ctrl+T etc.
     // (see AllowFrameToTranslateAccelerator for those).
     HRESULT hr = TranslateAccelerator(const_cast<MSG*>(&accel_message));
     if (hr != S_OK)
       hr = AllowFrameToTranslateAccelerator(accel_message);
 
     DVLOG(1) << __FUNCTION__ << " browser response: "
@@ skipping 164 matching lines @@
   EventHandlers onextensionready_;
 
   // Handle network requests when host network stack is used. Passed to the
   // automation client on initialization.
   scoped_ptr<UrlmonUrlRequestManager> url_fetcher_;
 
   HINSTANCE prev_resource_instance_;
 };
 
 #endif  // CHROME_FRAME_CHROME_FRAME_ACTIVEX_BASE_H_