Fixes for the chrome frame npapi test failures seen on the builders. These fa...

chrome_frame/chrome_frame_npapi.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_npapi.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_split.h"
@@ skipping 411 matching lines @@
                                  void* notify_data) {
   if (enabled_popups_) {
     // We have opened the URL so tell the browser to restore popup settings
     enabled_popups_ = false;
     npapi::PopPopupsEnabledState(instance_);
   }
 
   url_fetcher_.UrlNotify(url, reason, notify_data);
 }
 
-void ChromeFrameNPAPI::OnAcceleratorPressed(int tab_handle,
-                                            const MSG& accel_message) {
+void ChromeFrameNPAPI::OnAcceleratorPressed(const MSG& accel_message) {
   DVLOG(1) << __FUNCTION__
            << " msg:" << base::StringPrintf("0x%04X", accel_message.message)
            << " key:" << accel_message.wParam;
 
   // The host browser does call TranslateMessage on messages like WM_KEYDOWN
   // WM_KEYUP, etc, which will result in messages like WM_CHAR, WM_SYSCHAR, etc
   // being posted to the message queue. We don't post these messages here to
   // avoid these messages from getting handled twice.
   if (!is_privileged() &&
       accel_message.message != WM_CHAR &&
       accel_message.message != WM_DEADCHAR &&
       accel_message.message != WM_SYSCHAR &&
       accel_message.message != WM_SYSDEADCHAR) {
     // A very primitive way to handle keystrokes.
     // TODO(tommi): When we've implemented a way for chrome to
     //  know when keystrokes are handled (deterministically) on that side,
     //  then this function should get called and not otherwise.
     ::PostMessage(::GetParent(m_hWnd), accel_message.message,
                   accel_message.wParam, accel_message.lParam);
   }
 
   if (automation_client_.get()) {
     TabProxy* tab = automation_client_->tab();
     if (tab) {
       tab->ProcessUnhandledAccelerator(accel_message);
     }
   }
 }
 
-void ChromeFrameNPAPI::OnTabbedOut(int tab_handle, bool reverse) {
+void ChromeFrameNPAPI::OnTabbedOut(bool reverse) {
   DVLOG(1) << __FUNCTION__;
 
   ignore_setfocus_ = true;
   HWND parent = ::GetParent(m_hWnd);
   ::SetFocus(parent);
 
   INPUT input = {0};
   input.type = INPUT_KEYBOARD;
   input.ki.wVk = VK_TAB;
   SendInput(1, &input, sizeof(input));
   input.ki.dwFlags = KEYEVENTF_KEYUP;
   SendInput(1, &input, sizeof(input));
 
   ignore_setfocus_ = false;
 }
 
-void ChromeFrameNPAPI::OnOpenURL(int tab_handle,
-                                 const GURL& url,
+void ChromeFrameNPAPI::OnOpenURL(const GURL& url,
                                  const GURL& referrer,
                                  int open_disposition) {
   std::string target;
   switch (open_disposition) {
     case NEW_FOREGROUND_TAB:
       target = "_blank";
       break;
     case NEW_BACKGROUND_TAB:
       target = "_blank";
       break;
@@ skipping 306 matching lines @@
   if (hook)
     ::UnhookWindowsHookEx(hook);
 
   return ret;
 }
 
 void ChromeFrameNPAPI::OnBlur() {
   DVLOG(1) << __FUNCTION__;
 }
 
-void ChromeFrameNPAPI::OnLoad(int, const GURL& gurl) {
+void ChromeFrameNPAPI::OnLoad(const GURL& gurl) {
   DVLOG(1) << "Firing onload";
   FireEvent("load", gurl.spec());
 }
 
 void ChromeFrameNPAPI::OnLoadFailed(int error_code, const std::string& url) {
   FireEvent("loaderror", url);
 
   ScopedNpVariant result;
   InvokeDefault(onerror_handler_, url, &result);
 }
 
-void ChromeFrameNPAPI::OnMessageFromChromeFrame(int tab_handle,
-                                                const std::string& message,
+void ChromeFrameNPAPI::OnMessageFromChromeFrame(const std::string& message,
                                                 const std::string& origin,
                                                 const std::string& target) {
   bool private_message = false;
   if (target.compare("*") != 0) {
     if (is_privileged()) {
       private_message = true;
     } else {
       if (!HaveSameOrigin(target, document_url_)) {
         DLOG(WARNING) << "Dropping posted message since target doesn't match "
             "the current document's origin. target=" << target;
@@ skipping 673 matching lines @@
 }
 
 int32 ChromeFrameNPAPI::Write(NPStream* stream, int32 offset, int32 len,
                               void* buffer) {
   return url_fetcher_.Write(stream, offset, len, buffer);
 }
 
 NPError ChromeFrameNPAPI::DestroyStream(NPStream* stream, NPReason reason) {
   return url_fetcher_.DestroyStream(stream, reason);
 }