Clean up Automation and Chrome Frame IPC code.

chrome/test/automation/automation_proxy_uitest.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 <string>
 
 #include "app/app_switches.h"
 #include "app/message_box_flags.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
@@ skipping 624 matching lines @@
     : AutomationProxy(execution_timeout, false),
       host_window_style_(WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_VISIBLE),
       host_window_(NULL) {
 }
 
 ExternalTabUITestMockClient::~ExternalTabUITestMockClient() {
   EXPECT_TRUE(host_window_ == NULL);
 }
 
 void ExternalTabUITestMockClient::ReplyStarted(
-    const IPC::AutomationURLResponse* response,
+    const AutomationURLResponse* response,
     int tab_handle, int request_id) {
-  AutomationProxy::Send(new AutomationMsg_RequestStarted(0, tab_handle,
+  AutomationProxy::Send(new AutomationMsg_RequestStarted(tab_handle,
       request_id, *response));
 }
 
 void ExternalTabUITestMockClient::ReplyData(
     const std::string* data, int tab_handle, int request_id) {
-  AutomationProxy::Send(new AutomationMsg_RequestData(0, tab_handle,
+  AutomationProxy::Send(new AutomationMsg_RequestData(tab_handle,
                                                       request_id, *data));
 }
 
 void ExternalTabUITestMockClient::ReplyEOF(int tab_handle, int request_id) {
   ReplyEnd(URLRequestStatus(), tab_handle, request_id);
 }
 
 void ExternalTabUITestMockClient::ReplyEnd(const URLRequestStatus& status,
                                            int tab_handle, int request_id) {
-  AutomationProxy::Send(new AutomationMsg_RequestEnd(0, tab_handle,
+  AutomationProxy::Send(new AutomationMsg_RequestEnd(tab_handle,
                                                      request_id, status));
 }
 
 void ExternalTabUITestMockClient::Reply404(int tab_handle, int request_id) {
-  const IPC::AutomationURLResponse notfound("", "HTTP/1.1 404\r\n\r\n", 0,
-                                            base::Time(), "", 0);
+  const AutomationURLResponse notfound("", "HTTP/1.1 404\r\n\r\n", 0,
+                                       base::Time(), "", 0);
   ReplyStarted(&notfound, tab_handle, request_id);
   ReplyEOF(tab_handle, request_id);
 }
 
 void ExternalTabUITestMockClient::ServeHTMLData(int tab_handle,
                                                 const GURL& url,
                                                 const std::string& data) {
-  EXPECT_CALL(*this, OnRequestStart(tab_handle, _, testing::AllOf(
-    testing::Field(&IPC::AutomationURLRequest::url, url.spec()),
-      testing::Field(&IPC::AutomationURLRequest::method, StrEq("GET")))))
+  EXPECT_CALL(*this, OnRequestStart(tab_handle, testing::AllOf(
+    testing::Field(&AutomationURLRequest::url, url.spec()),
+      testing::Field(&AutomationURLRequest::method, StrEq("GET")))))
     .Times(1)
-    .WillOnce(testing::WithArgs<0, 1>(testing::Invoke(CreateFunctor(this,
+    .WillOnce(testing::WithArgs<0, 0>(testing::Invoke(CreateFunctor(this,
         &ExternalTabUITestMockClient::ReplyStarted, &http_200))));
 
-  EXPECT_CALL(*this, OnRequestRead(tab_handle, _, testing::Gt(0)))
+  EXPECT_CALL(*this, OnRequestRead(tab_handle, testing::Gt(0)))
       .Times(2)
-      .WillOnce(testing::WithArgs<0, 1>(testing::Invoke(CreateFunctor(this,
+      .WillOnce(testing::WithArgs<0, 0>(testing::Invoke(CreateFunctor(this,
           &ExternalTabUITestMockClient::ReplyData, &data))))
-      .WillOnce(testing::WithArgs<0, 1>(testing::Invoke(CreateFunctor(this,
+      .WillOnce(testing::WithArgs<0, 0>(testing::Invoke(CreateFunctor(this,
           &ExternalTabUITestMockClient::ReplyEOF))));
 }
 
 void ExternalTabUITestMockClient::IgnoreFavIconNetworkRequest() {
   // Ignore favicon.ico
-  EXPECT_CALL(*this, OnRequestStart(_, _, testing::AllOf(
-          testing::Field(&IPC::AutomationURLRequest::url,
+  EXPECT_CALL(*this, OnRequestStart(_, testing::AllOf(
+          testing::Field(&AutomationURLRequest::url,
                          testing::EndsWith("favicon.ico")),
-          testing::Field(&IPC::AutomationURLRequest::method, StrEq("GET")))))
+          testing::Field(&AutomationURLRequest::method, StrEq("GET")))))
       .Times(testing::AnyNumber())
-      .WillRepeatedly(testing::WithArgs<0, 1>(testing::Invoke(
+      .WillRepeatedly(testing::WithArgs<0, 0>(testing::Invoke(
           CreateFunctor(this, &ExternalTabUITestMockClient::ReplyEnd,
                 URLRequestStatus(URLRequestStatus::FAILED, 0)))));
 }
 
 void ExternalTabUITestMockClient::InvalidateHandle(
     const IPC::Message& message) {
   void* iter = NULL;
   int handle;
   ASSERT_TRUE(message.ReadInt(&iter, &handle));
 
   // Call base class
   AutomationProxy::InvalidateHandle(message);
   HandleClosed(handle);
 }
 
 // Most of the time we need external tab with these settings.
-const IPC::ExternalTabSettings ExternalTabUITestMockClient::default_settings(
+const ExternalTabSettings ExternalTabUITestMockClient::default_settings(
     NULL, gfx::Rect(),  // will be replaced by CreateHostWindowAndTab
     WS_CHILD | WS_VISIBLE,
     false,   // is_off_the_record
     true,    // load_requests_via_automation
     true,    // handle_top_level_requests
     GURL(),  // initial_url
     GURL(),  // referrer
     false,   // infobars_enabled
     false);  // route_all_top_level_navigations
 
 // static
-const IPC::AutomationURLResponse ExternalTabUITestMockClient::http_200(
+const AutomationURLResponse ExternalTabUITestMockClient::http_200(
     "",
     "HTTP/0.9 200\r\n\r\n",
     0,
     base::Time(),
     "",
     0);
 
 void ExternalTabUITestMockClient::OnMessageReceived(const IPC::Message& msg) {
   IPC_BEGIN_MESSAGE_MAP(ExternalTabUITestMockClient, msg)
     IPC_MESSAGE_HANDLER(AutomationMsg_DidNavigate, OnDidNavigate)
     IPC_MESSAGE_HANDLER(AutomationMsg_ForwardMessageToExternalHost,
         OnForwardMessageToExternalHost)
     IPC_MESSAGE_HANDLER(AutomationMsg_RequestStart, OnRequestStart)
     IPC_MESSAGE_HANDLER(AutomationMsg_RequestRead, OnRequestRead)
     IPC_MESSAGE_HANDLER(AutomationMsg_RequestEnd, OnRequestEnd)
     IPC_MESSAGE_HANDLER(AutomationMsg_SetCookieAsync, OnSetCookieAsync)
     IPC_MESSAGE_HANDLER(AutomationMsg_TabLoaded, OnLoad)
     IPC_MESSAGE_HANDLER(AutomationMsg_AttachExternalTab, OnAttachExternalTab)
     IPC_MESSAGE_HANDLER(AutomationMsg_OpenURL, OnOpenURL)
     IPC_MESSAGE_HANDLER(AutomationMsg_NavigationStateChanged,
-        OnNavigationStateChanged)
+                        OnNavigationStateChanged)
   IPC_END_MESSAGE_MAP()
 }
 
 scoped_refptr<TabProxy> ExternalTabUITestMockClient::CreateHostWindowAndTab(
-    const IPC::ExternalTabSettings& settings) {
+    const ExternalTabSettings& settings) {
   EXPECT_THAT(settings.parent, testing::IsNull());
 
   host_window_ = CreateWindowW(L"Button", NULL, host_window_style_,
       CW_USEDEFAULT,  CW_USEDEFAULT, CW_USEDEFAULT,  CW_USEDEFAULT,
       NULL, NULL, NULL, NULL);
   EXPECT_THAT(host_window_, testing::Truly(::IsWindow));
   RECT client_area = {0};
   ::GetClientRect(host_window_, &client_area);
 
-  IPC::ExternalTabSettings s = settings;
+  ExternalTabSettings s = settings;
   s.parent = host_window_;
   s.dimensions = client_area;
 
   HWND container_wnd = NULL;
   HWND tab_wnd = NULL;
   scoped_refptr<TabProxy> tab(CreateExternalTab(s, &container_wnd, &tab_wnd));
 
   EXPECT_TRUE(tab != NULL);
   EXPECT_NE(FALSE, ::IsWindow(container_wnd));
   EXPECT_NE(FALSE, ::IsWindow(tab_wnd));
   return tab;
 }
 
 scoped_refptr<TabProxy> ExternalTabUITestMockClient::CreateTabWithUrl(
     const GURL& initial_url) {
-  IPC::ExternalTabSettings settings =
+  ExternalTabSettings settings =
       ExternalTabUITestMockClient::default_settings;
   settings.initial_url = initial_url;
   return CreateHostWindowAndTab(settings);
 }
 
 void ExternalTabUITestMockClient::NavigateInExternalTab(int tab_handle,
     const GURL& url, const GURL& referrer /* = GURL()*/) {
-  channel_->ChannelProxy::Send(new AutomationMsg_NavigateInExternalTab(0,
+  channel_->ChannelProxy::Send(new AutomationMsg_NavigateInExternalTab(
         tab_handle, url, referrer, NULL));
 }
 
 void ExternalTabUITestMockClient::ConnectToExternalTab(gfx::NativeWindow parent,
-    const IPC::AttachExternalTabParams& attach_params) {
+    const AttachExternalTabParams& attach_params) {
   gfx::NativeWindow tab_container = NULL;
   gfx::NativeWindow tab_window = NULL;
   int tab_handle = 0;
   int session_id = -1;
 
-  IPC::SyncMessage* message = new AutomationMsg_ConnectExternalTab(0,
+  IPC::SyncMessage* message = new AutomationMsg_ConnectExternalTab(
       attach_params.cookie, true, NULL, &tab_container, &tab_window,
       &tab_handle, &session_id);
   channel_->Send(message);
 
   RECT rect;
   ::GetClientRect(parent, &rect);
-  IPC::Reposition_Params params = {0};
+  Reposition_Params params = {0};
   params.window = tab_container;
   params.flags = SWP_NOZORDER | SWP_SHOWWINDOW;
   params.width = rect.right - rect.left;
   params.height = rect.bottom - rect.top;
   params.set_parent = true;
   params.parent_window = parent;
 
-  channel_->Send(new AutomationMsg_TabReposition(0, tab_handle, params));
+  channel_->Send(new AutomationMsg_TabReposition(tab_handle, params));
   ::ShowWindow(parent, SW_SHOWNORMAL);
 }
 
 void ExternalTabUITestMockClient::NavigateThroughUserGesture() {
   ASSERT_THAT(host_window_, testing::Truly(::IsWindow));
   HWND tab_container = ::GetWindow(host_window_, GW_CHILD);
   ASSERT_THAT(tab_container, testing::Truly(::IsWindow));
   HWND tab = ::GetWindow(tab_container, GW_CHILD);
   ASSERT_THAT(tab, testing::Truly(::IsWindow));
   HWND renderer_window = ::GetWindow(tab, GW_CHILD);
@@ skipping 33 matching lines @@
   return mock_;
 }
 
 // Create with specifying a url
 // Flaky, http://crbug.com/32293
 TEST_F(ExternalTabUITest, FLAKY_CreateExternalTab1) {
   scoped_refptr<TabProxy> tab;
   TimedMessageLoopRunner loop(MessageLoop::current());
   ASSERT_THAT(mock_, testing::NotNull());
 
-  EXPECT_CALL(*mock_, OnNavigationStateChanged(_, _, _))
+  EXPECT_CALL(*mock_, OnNavigationStateChanged(_, _))
       .Times(testing::AnyNumber());
 
-  EXPECT_CALL(*mock_, OnDidNavigate(testing::_, testing::_))
+  EXPECT_CALL(*mock_, OnDidNavigate(testing::_))
       .Times(1)
       .WillOnce(testing::InvokeWithoutArgs(mock_,
                 &ExternalTabUITestMockClient::DestroyHostWindow));
 
   EXPECT_CALL(*mock_, HandleClosed(1))
       .Times(1)
       .WillOnce(QUIT_LOOP(&loop));
 
   tab = mock_->CreateTabWithUrl(GURL(simple_data_url));
   loop.RunFor(action_max_timeout_ms());
 }
 
 // Create with empty url and then navigate
 // Flaky, http://crbug.com/32293
 TEST_F(ExternalTabUITest, FLAKY_CreateExternalTab2) {
   scoped_refptr<TabProxy> tab;
   TimedMessageLoopRunner loop(MessageLoop::current());
   ASSERT_THAT(mock_, testing::NotNull());
 
-  EXPECT_CALL(*mock_, OnNavigationStateChanged(_, _, _))
+  EXPECT_CALL(*mock_, OnNavigationStateChanged(_, _))
       .Times(testing::AnyNumber());
 
-  EXPECT_CALL(*mock_, OnDidNavigate(testing::_, testing::_))
+  EXPECT_CALL(*mock_, OnDidNavigate(testing::_))
     .Times(1)
     .WillOnce(testing::InvokeWithoutArgs(mock_,
               &ExternalTabUITestMockClient::DestroyHostWindow));
 
   EXPECT_CALL(*mock_, HandleClosed(1))
     .Times(1)
     .WillOnce(QUIT_LOOP(&loop));
 
   tab = mock_->CreateTabWithUrl(GURL());
   mock_->NavigateInExternalTab(tab->handle(), GURL(simple_data_url));
   loop.RunFor(action_max_timeout_ms());
 }
 
 // FLAKY: http://crbug.com/60409
 TEST_F(ExternalTabUITest, FLAKY_IncognitoMode) {
   scoped_refptr<TabProxy> tab;
   TimedMessageLoopRunner loop(MessageLoop::current());
   ASSERT_THAT(mock_, testing::NotNull());
 
   GURL url("http://anatomyofmelancholy.net");
   std::string cookie = "robert=burton; expires=Thu, 13 Oct 2011 05:04:03 UTC;";
 
   EXPECT_CALL(*mock_, HandleClosed(1)).Times(1);
 
-  IPC::ExternalTabSettings incognito =
+  ExternalTabSettings incognito =
       ExternalTabUITestMockClient::default_settings;
   incognito.is_off_the_record = true;
   // SetCookie is a sync call and deadlock can happen if window is visible,
   // since it shares same thread with AutomationProxy.
   mock_->host_window_style_ &= ~WS_VISIBLE;
   tab = mock_->CreateHostWindowAndTab(incognito);
   std::string value_result;
 
   EXPECT_TRUE(tab->SetCookie(url, cookie));
   EXPECT_TRUE(tab->GetCookieByName(url, "robert", &value_result));
@@ skipping 16 matching lines @@
   CloseBrowserAndServer();
   tab = NULL;
 }
 
 // FLAKY: http://crbug.com/44617
 TEST_F(ExternalTabUITest, FLAKY_TabPostMessage) {
   scoped_refptr<TabProxy> tab;
   TimedMessageLoopRunner loop(MessageLoop::current());
   ASSERT_THAT(mock_, testing::NotNull());
 
-  EXPECT_CALL(*mock_, OnNavigationStateChanged(_, _, _))
+  EXPECT_CALL(*mock_, OnNavigationStateChanged(_, _))
       .Times(testing::AnyNumber());
-  EXPECT_CALL(*mock_, OnLoad(_, _)).Times(testing::AnyNumber());
+  EXPECT_CALL(*mock_, OnLoad(_)).Times(testing::AnyNumber());
 
   std::string content =
       "data:text/html,<html><head><script>"
       "function onload() {"
       "  window.externalHost.onmessage = onMessage;"
       "}"
       "function onMessage(evt) {"
       "  window.externalHost.postMessage(evt.data, '*');"
       "}"
       "</script></head>"
       "<body onload='onload()'>external tab test<br></div>"
       "</body></html>";
 
-  EXPECT_CALL(*mock_, OnDidNavigate(testing::_, testing::_))
+  EXPECT_CALL(*mock_, OnDidNavigate(testing::_))
       .Times(1)
       .WillOnce(testing::InvokeWithoutArgs(CreateFunctor(
           ReceivePointer(tab),
           &TabProxy::HandleMessageFromExternalHost,
           std::string("Hello from gtest"),
           std::string("null"), std::string("*"))));
 
-  EXPECT_CALL(*mock_, OnForwardMessageToExternalHost(testing::_,
+  EXPECT_CALL(*mock_, OnForwardMessageToExternalHost(
           testing::StrEq("Hello from gtest"), testing::_, testing::_))
       .Times(1)
       .WillOnce(testing::DoAll(
           testing::InvokeWithoutArgs(CreateFunctor(mock_,
               &ExternalTabUITestMockClient::DestroyHostWindow)),
           QUIT_LOOP_SOON(&loop, 50)));
 
   EXPECT_CALL(*mock_, HandleClosed(1)).Times(1);
 
   tab = mock_->CreateTabWithUrl(GURL(content));
   loop.RunFor(action_max_timeout_ms());
 }
 
 // Flaky: http://crbug.com/62143
 TEST_F(ExternalTabUITest, FLAKY_PostMessageTarget)  {
   net::TestServer test_server(
       net::TestServer::TYPE_HTTP,
       FilePath(FILE_PATH_LITERAL("chrome/test/data/external_tab")));
   ASSERT_TRUE(test_server.Start());
 
   scoped_refptr<TabProxy> tab;
   TimedMessageLoopRunner loop(MessageLoop::current());
   ASSERT_THAT(mock_, testing::NotNull());
-  EXPECT_CALL(*mock_, OnNavigationStateChanged(_, _, _))
+  EXPECT_CALL(*mock_, OnNavigationStateChanged(_, _))
       .Times(testing::AnyNumber());
-  EXPECT_CALL(*mock_, OnLoad(_, _)).Times(testing::AnyNumber());
+  EXPECT_CALL(*mock_, OnLoad(_)).Times(testing::AnyNumber());
 
   std::string kTestMessage("Hello from gtest");
   std::string kTestOrigin("http://www.external.tab");
 
-  EXPECT_CALL(*mock_, OnDidNavigate(1, testing::_))
+  EXPECT_CALL(*mock_, OnDidNavigate(testing::_))
       .Times(1)
       .WillOnce(testing::InvokeWithoutArgs(CreateFunctor(
           ReceivePointer(tab),
           &TabProxy::HandleMessageFromExternalHost,
           kTestMessage, kTestOrigin, std::string("http://localhost:1337/"))));
 
-  EXPECT_CALL(*mock_, OnForwardMessageToExternalHost(1,
+  EXPECT_CALL(*mock_, OnForwardMessageToExternalHost(
                     testing::StrEq(kTestMessage),
                     testing::_,
                     testing::StrEq(GURL(kTestOrigin).GetOrigin().spec())))
       .Times(1)
       .WillOnce(testing::DoAll(
           testing::InvokeWithoutArgs(CreateFunctor(mock_,
               &ExternalTabUITestMockClient::DestroyHostWindow)),
           QUIT_LOOP_SOON(&loop, 50)));
 
   EXPECT_CALL(*mock_, HandleClosed(1)).Times(1);
 
-  IPC::ExternalTabSettings s = ExternalTabUITestMockClient::default_settings;
+  ExternalTabSettings s = ExternalTabUITestMockClient::default_settings;
   s.load_requests_via_automation = false;
   s.initial_url = GURL("http://localhost:1337/files/post_message.html");
   tab = mock_->CreateHostWindowAndTab(s);
   loop.RunFor(action_max_timeout_ms());
 }
 
 // Flaky, http://crbug.com/42545.
 TEST_F(ExternalTabUITest, FLAKY_HostNetworkStack) {
   scoped_refptr<TabProxy> tab;
   TimedMessageLoopRunner loop(MessageLoop::current());
   ASSERT_THAT(mock_, testing::NotNull());
-  EXPECT_CALL(*mock_, OnNavigationStateChanged(_, _, _))
+  EXPECT_CALL(*mock_, OnNavigationStateChanged(_, _))
       .Times(testing::AnyNumber());
-  EXPECT_CALL(*mock_, OnLoad(_, _)).Times(testing::AnyNumber());
+  EXPECT_CALL(*mock_, OnLoad(_)).Times(testing::AnyNumber());
 
   std::string url = "http://placetogo.org";
 
   testing::InSequence sequence;
-  EXPECT_CALL(*mock_, OnRequestStart(1, 2, testing::AllOf(
-          testing::Field(&IPC::AutomationURLRequest::url, StrEq(url + "/")),
-          testing::Field(&IPC::AutomationURLRequest::method, StrEq("GET")))))
+  EXPECT_CALL(*mock_, OnRequestStart(2, testing::AllOf(
+          testing::Field(&AutomationURLRequest::url, StrEq(url + "/")),
+          testing::Field(&AutomationURLRequest::method, StrEq("GET")))))
       .Times(1)
       // We can simply do CreateFunctor(1, 2, &http_200) since we know the
       // tab handle and request id, but using WithArgs<> is much more fancy :)
-      .WillOnce(testing::WithArgs<0, 1>(testing::Invoke(CreateFunctor(mock_,
+      .WillOnce(testing::WithArgs<0, 0>(testing::Invoke(CreateFunctor(mock_,
           &ExternalTabUITestMockClient::ReplyStarted,
           &ExternalTabUITestMockClient::http_200))));
 
   // Return some trivial page, that have a link to a "logo.gif" image
   const std::string data = "<!DOCTYPE html><title>Hello</title>"
                            "<img src=\"logo.gif\">";
 
-  EXPECT_CALL(*mock_, OnRequestRead(1, 2, testing::Gt(0)))
+  EXPECT_CALL(*mock_, OnRequestRead(2, testing::Gt(0)))
       .Times(2)
       .WillOnce(testing::InvokeWithoutArgs(CreateFunctor(mock_,
           &ExternalTabUITestMockClient::ReplyData, &data, 1, 2)))
-      .WillOnce(testing::WithArgs<0, 1>(testing::Invoke(CreateFunctor(mock_,
+      .WillOnce(testing::WithArgs<0, 0>(testing::Invoke(CreateFunctor(mock_,
           &ExternalTabUITestMockClient::ReplyEOF))));
 
   // Expect navigation is ok.
-  EXPECT_CALL(*mock_, OnDidNavigate(1, testing::Field(&IPC::NavigationInfo::url,
-                                                      GURL(url))))
+  EXPECT_CALL(*mock_, OnDidNavigate(testing::Field(&NavigationInfo::url,
+                                                   GURL(url))))
       .Times(1);
 
   // Expect GET request for logo.gif
-  EXPECT_CALL(*mock_, OnRequestStart(1, 3, testing::AllOf(
-      testing::Field(&IPC::AutomationURLRequest::url, StrEq(url + "/logo.gif")),
-      testing::Field(&IPC::AutomationURLRequest::method, StrEq("GET")))))
+  EXPECT_CALL(*mock_, OnRequestStart(3, testing::AllOf(
+      testing::Field(&AutomationURLRequest::url, StrEq(url + "/logo.gif")),
+      testing::Field(&AutomationURLRequest::method, StrEq("GET")))))
       .Times(1)
       .WillOnce(testing::InvokeWithoutArgs(CreateFunctor(mock_,
           &ExternalTabUITestMockClient::Reply404, 1, 3)));
 
-  EXPECT_CALL(*mock_, OnRequestRead(1, 3, testing::Gt(0)))
+  EXPECT_CALL(*mock_, OnRequestRead(3, testing::Gt(0)))
     .Times(1);
 
   // Chrome makes a brave request for favicon.ico
-  EXPECT_CALL(*mock_, OnRequestStart(1, 4, testing::AllOf(
-      testing::Field(&IPC::AutomationURLRequest::url,
+  EXPECT_CALL(*mock_, OnRequestStart(4, testing::AllOf(
+      testing::Field(&AutomationURLRequest::url,
                      StrEq(url + "/favicon.ico")),
-      testing::Field(&IPC::AutomationURLRequest::method, StrEq("GET")))))
+      testing::Field(&AutomationURLRequest::method, StrEq("GET")))))
       .Times(1)
       .WillOnce(testing::DoAll(
           testing::InvokeWithoutArgs(CreateFunctor(mock_,
               &ExternalTabUITestMockClient::Reply404, 1, 4)),
           testing::InvokeWithoutArgs(CreateFunctor(mock_,
               &ExternalTabUITestMockClient::DestroyHostWindow))));
 
   EXPECT_CALL(*mock_, HandleClosed(1)).Times(1);
 
-  EXPECT_CALL(*mock_, OnRequestRead(1, 4, testing::Gt(0)))
+  EXPECT_CALL(*mock_, OnRequestRead(4, testing::Gt(0)))
     .Times(1)
     .WillOnce(QUIT_LOOP_SOON(&loop, 300));
 
   tab = mock_->CreateTabWithUrl(GURL(url));
   loop.RunFor(action_max_timeout_ms());
 }
 
 // Flaky, http://crbug.com/61023.
 TEST_F(ExternalTabUITest, FLAKY_HostNetworkStackAbortRequest) {
   scoped_refptr<TabProxy> tab;
   TimedMessageLoopRunner loop(MessageLoop::current());
   ASSERT_THAT(mock_, testing::NotNull());
-  EXPECT_CALL(*mock_, OnNavigationStateChanged(_, _, _))
+  EXPECT_CALL(*mock_, OnNavigationStateChanged(_, _))
       .Times(testing::AnyNumber());
 
   std::string url = "http://placetogo.org";
 
   testing::InSequence sequence;
-  EXPECT_CALL(*mock_, OnRequestStart(1, 2, testing::AllOf(
-          testing::Field(&IPC::AutomationURLRequest::url, StrEq(url + "/")),
-          testing::Field(&IPC::AutomationURLRequest::method, StrEq("GET")))))
+  EXPECT_CALL(*mock_, OnRequestStart(2, testing::AllOf(
+          testing::Field(&AutomationURLRequest::url, StrEq(url + "/")),
+          testing::Field(&AutomationURLRequest::method, StrEq("GET")))))
       .Times(1)
       // We can simply do CreateFunctor(1, 2, &http_200) since we know the
       // tab handle and request id, but using WithArgs<> is much more fancy :)
-      .WillOnce(testing::WithArgs<0, 1>(testing::Invoke(CreateFunctor(mock_,
+      .WillOnce(testing::WithArgs<0, 0>(testing::Invoke(CreateFunctor(mock_,
           &ExternalTabUITestMockClient::ReplyStarted,
           &ExternalTabUITestMockClient::http_200))));
 
   // Return some trivial page, that have a link to a "logo.gif" image
   const std::string data = "<!DOCTYPE html><title>Hello";
 
-  EXPECT_CALL(*mock_, OnRequestRead(1, 2, testing::Gt(0)))
+  EXPECT_CALL(*mock_, OnRequestRead(2, testing::Gt(0)))
       .Times(2)
       .WillOnce(testing::InvokeWithoutArgs(CreateFunctor(mock_,
           &ExternalTabUITestMockClient::ReplyData, &data, 1, 2)))
-      .WillOnce(testing::WithArgs<0, 1>(
+      .WillOnce(testing::WithArgs<0, 0>(
           testing::InvokeWithoutArgs(CreateFunctor(mock_,
               &ExternalTabUITestMockClient::DestroyHostWindow))));
 
   EXPECT_CALL(*mock_, HandleClosed(1)).Times(1);
 
-  EXPECT_CALL(*mock_, OnRequestEnd(1, 2, testing::_))
+  EXPECT_CALL(*mock_, OnRequestEnd(2, testing::_))
       .Times(1)
       .WillOnce(QUIT_LOOP_SOON(&loop, 300));
 
   tab = mock_->CreateTabWithUrl(GURL(url));
   loop.RunFor(action_max_timeout_ms());
 }
 
 // Flaky, http://crbug.com/61023.
 TEST_F(ExternalTabUITest, FLAKY_HostNetworkStackUnresponsiveRenderer) {
   scoped_refptr<TabProxy> tab;
   TimedMessageLoopRunner loop(MessageLoop::current());
   ASSERT_THAT(mock_, testing::NotNull());
-  EXPECT_CALL(*mock_, OnNavigationStateChanged(_, _, _))
+  EXPECT_CALL(*mock_, OnNavigationStateChanged(_, _))
       .Times(testing::AnyNumber());
-  EXPECT_CALL(*mock_, OnLoad(_, _)).Times(testing::AnyNumber());
+  EXPECT_CALL(*mock_, OnLoad(_)).Times(testing::AnyNumber());
 
   std::string url = "http://placetogo.org";
 
-  EXPECT_CALL(*mock_, OnRequestStart(1, 3, testing::_))
+  EXPECT_CALL(*mock_, OnRequestStart(3, testing::_))
       .Times(testing::AnyNumber());
-  EXPECT_CALL(*mock_, OnDidNavigate(_, _)).Times(testing::AnyNumber());
+  EXPECT_CALL(*mock_, OnDidNavigate(_)).Times(testing::AnyNumber());
 
   testing::InSequence sequence;
-  EXPECT_CALL(*mock_, OnRequestStart(1, 2, testing::AllOf(
-          testing::Field(&IPC::AutomationURLRequest::url, StrEq(url + "/")),
-          testing::Field(&IPC::AutomationURLRequest::method, StrEq("GET")))))
+  EXPECT_CALL(*mock_, OnRequestStart(2, testing::AllOf(
+          testing::Field(&AutomationURLRequest::url, StrEq(url + "/")),
+          testing::Field(&AutomationURLRequest::method, StrEq("GET")))))
       .Times(1)
       // We can simply do CreateFunctor(1, 2, &http_200) since we know the
       // tab handle and request id, but using WithArgs<> is much more fancy :)
-      .WillOnce(testing::WithArgs<0, 1>(testing::Invoke(CreateFunctor(mock_,
+      .WillOnce(testing::WithArgs<0, 0>(testing::Invoke(CreateFunctor(mock_,
           &ExternalTabUITestMockClient::ReplyStarted,
           &ExternalTabUITestMockClient::http_200))));
 
   const std::string head = "<html><title>Hello</title><body>";
 
   const std::string data = "<table border=\"1\"><tr><th>Month</th>"
                            "<th>Savings</th></tr><tr><td>January</td>"
                            "<td>$100</td></tr><tr><td>February</td>"
                            "<td>$100</td></tr><tr><td>March</td>"
                            "<td>$100</td></tr><tr><td>April</td>"
                            "<td>$100</td></tr><tr><td>May</td>"
                            "<td>$100</td></tr><tr><td>June</td>"
                            "<td>$100</td></tr><tr><td>July</td>"
                            "<td>$100</td></tr><tr><td>Aug</td>"
                            "<td>$100</td></tr><tr><td>Sept</td>"
                            "<td>$100</td></tr><tr><td>Oct</td>"
                            "<td>$100</td></tr><tr><td>Nov</td>"
                            "<td>$100</td></tr><tr><td>Dec</td>"
                            "<td>$100</td></tr></table>";
 
   const std::string tail = "</body></html>";
 
-  EXPECT_CALL(*mock_, OnRequestRead(1, 2, testing::Gt(0)))
+  EXPECT_CALL(*mock_, OnRequestRead(2, testing::Gt(0)))
       .Times(1)
       .WillOnce(testing::InvokeWithoutArgs(CreateFunctor(mock_,
           &ExternalTabUITestMockClient::ReplyData, &head, 1, 2)));
 
-  EXPECT_CALL(*mock_, OnRequestRead(1, 2, testing::Gt(0)))
+  EXPECT_CALL(*mock_, OnRequestRead(2, testing::Gt(0)))
       .Times(100)
       .WillRepeatedly(testing::InvokeWithoutArgs(CreateFunctor(mock_,
               &ExternalTabUITestMockClient::ReplyData, &data, 1, 2)));
 
-  EXPECT_CALL(*mock_, OnRequestRead(1, 2, testing::Gt(0)))
+  EXPECT_CALL(*mock_, OnRequestRead(2, testing::Gt(0)))
       .Times(testing::AnyNumber())
       .WillOnce(testing::DoAll(
           testing::InvokeWithoutArgs(CreateFunctor(mock_,
               &ExternalTabUITestMockClient::ReplyData, &tail, 1, 2)),
           testing::InvokeWithoutArgs(CreateFunctor(mock_,
               &ExternalTabUITestMockClient::ReplyEOF, 1, 2)),
           QUIT_LOOP_SOON(&loop, 300)));
   EXPECT_CALL(*mock_, HandleClosed(1)).Times(1);
 
   tab = mock_->CreateTabWithUrl(GURL(url));
@@ skipping 18 matching lines @@
 #endif
 
 // Testing AutomationMsg_AttachExternalTab callback from Chrome.
 // Open a popup window with window.open() call. The created popup window opens
 // another popup window (again using window.open() call).
 TEST_F(ExternalTabUITestPopupEnabled, MAYBE_WindowDotOpen) {
   TimedMessageLoopRunner loop(MessageLoop::current());
   ASSERT_THAT(mock_, testing::NotNull());
   mock_->IgnoreFavIconNetworkRequest();
   // Ignore navigation state changes.
-  EXPECT_CALL(*mock_, OnNavigationStateChanged(_, _, _))
+  EXPECT_CALL(*mock_, OnNavigationStateChanged(_, _))
       .Times(testing::AnyNumber());
-  EXPECT_CALL(*mock_, OnDidNavigate(_, _)).Times(testing::AnyNumber());
+  EXPECT_CALL(*mock_, OnDidNavigate(_)).Times(testing::AnyNumber());
 
   GURL main_url("http://placetogo.com/");
   std::string main_html =
     "<html><head><script type='text/javascript' language='JavaScript'>"
     "window.open('popup1.html','','toolbar=no,menubar=no,location=yes,"
     "height=320,width=300,left=1');"
     "</script></head><body>Main.</body></html>";
   mock_->ServeHTMLData(1, main_url, main_html);
-  EXPECT_CALL(*mock_, OnLoad(1, _)).Times(1);
+  EXPECT_CALL(*mock_, OnLoad(_)).Times(1);
 
   GURL popup1_url("http://placetogo.com/popup1.html");
   std::string popup1_html =
     "<html><head><script type='text/javascript' language='JavaScript'>"
     "window.open('popup2.html','','');"
     "</script></head><body>Popup1.</body></html>";
   mock_->ServeHTMLData(2, popup1_url, popup1_html);
-  EXPECT_CALL(*mock_, OnLoad(2, _)).Times(1);
+  EXPECT_CALL(*mock_, OnLoad(_)).Times(1);
 
   GURL popup2_url("http://placetogo.com/popup2.html");
   std::string popup2_html = "<html><body>Popup2.</body></html>";
   mock_->ServeHTMLData(3, popup2_url, popup2_html);
-  EXPECT_CALL(*mock_, OnLoad(3, _)).Times(1)
+  EXPECT_CALL(*mock_, OnLoad(_)).Times(1)
       .WillOnce(QUIT_LOOP_SOON(&loop, 500));
 
   DWORD style = WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN;
   HWND popup1_host = CreateWindowW(L"Button", L"popup1_host", style,
       CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
       NULL, NULL, NULL, NULL);
 
   HWND popup2_host = CreateWindowW(L"Button", L"popup2_host", style,
       CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,  CW_USEDEFAULT,
       NULL, NULL, NULL, NULL);
 
-  EXPECT_CALL(*mock_, OnAttachExternalTab(1, _))
+  EXPECT_CALL(*mock_, OnAttachExternalTab(_))
       .Times(1)
-      .WillOnce(testing::WithArgs<1>(testing::Invoke(CreateFunctor(mock_,
+      .WillOnce(testing::WithArgs<0>(testing::Invoke(CreateFunctor(mock_,
           &ExternalTabUITestMockClient::ConnectToExternalTab, popup1_host))));
 
-  EXPECT_CALL(*mock_, OnAttachExternalTab(2, _))
+  EXPECT_CALL(*mock_, OnAttachExternalTab(_))
     .Times(1)
-    .WillOnce(testing::WithArgs<1>(testing::Invoke(CreateFunctor(mock_,
+    .WillOnce(testing::WithArgs<0>(testing::Invoke(CreateFunctor(mock_,
         &ExternalTabUITestMockClient::ConnectToExternalTab, popup2_host))));
 
   mock_->CreateTabWithUrl(main_url);
 
   loop.RunFor(action_max_timeout_ms());
 
   EXPECT_CALL(*mock_, HandleClosed(1));
   EXPECT_CALL(*mock_, HandleClosed(2));
   EXPECT_CALL(*mock_, HandleClosed(3));
 
   mock_->DestroyHostWindow();
   ::DestroyWindow(popup1_host);
   ::DestroyWindow(popup2_host);
 }
 
 // Open a new window by simulating a user gesture through keyboard.
 TEST_F(ExternalTabUITestPopupEnabled, MAYBE_UserGestureTargetBlank) {
   TimedMessageLoopRunner loop(MessageLoop::current());
   ASSERT_THAT(mock_, testing::NotNull());
   mock_->IgnoreFavIconNetworkRequest();
   // Ignore navigation state changes.
-  EXPECT_CALL(*mock_, OnNavigationStateChanged(_, _, _))
+  EXPECT_CALL(*mock_, OnNavigationStateChanged(_, _))
       .Times(testing::AnyNumber());
-  EXPECT_CALL(*mock_, OnDidNavigate(_, _)).Times(testing::AnyNumber());
+  EXPECT_CALL(*mock_, OnDidNavigate(_)).Times(testing::AnyNumber());
 
   GURL main_url("http://placetogo.com/");
   std::string main_html = "<!DOCTYPE html><title>Hello</title>"
       "<a href='http://foo.com/' target='_blank'>Link</a>";
   mock_->ServeHTMLData(1, main_url, main_html);
 
   HWND foo_host = CreateWindowW(L"Button", L"foo_host",
       WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN, CW_USEDEFAULT, CW_USEDEFAULT,
       CW_USEDEFAULT,  CW_USEDEFAULT, NULL, NULL, NULL, NULL);
 
   testing::InSequence s;
-  EXPECT_CALL(*mock_, OnLoad(1, _))
+  EXPECT_CALL(*mock_, OnLoad(_))
       .WillOnce(testing::InvokeWithoutArgs(testing::CreateFunctor(mock_,
           &ExternalTabUITestMockClient::NavigateThroughUserGesture)));
 
-  EXPECT_CALL(*mock_, OnAttachExternalTab(1, _))
+  EXPECT_CALL(*mock_, OnAttachExternalTab(_))
       .Times(1)
       .WillOnce(QUIT_LOOP_SOON(&loop, 500));
 
   mock_->CreateTabWithUrl(main_url);
   loop.RunFor(action_max_timeout_ms());
 
   EXPECT_CALL(*mock_, HandleClosed(1));
   ::DestroyWindow(foo_host);
   mock_->DestroyHostWindow();
 }
@@ skipping 371 matching lines @@
   int diff_pixels_count = 0;
   for (int x = 0; x < img_size.width(); ++x) {
     for (int y = 0; y < img_size.height(); ++y) {
       if (*snapshot_bmp.getAddr32(x, y) != *reference_bmp.getAddr32(x, y)) {
         ++diff_pixels_count;
       }
     }
   }
   ASSERT_EQ(diff_pixels_count, 0);
 }