Clean up Automation and Chrome Frame IPC code.

chrome_frame/external_tab_test.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/task.h"
 #include "base/thread.h"
 #include "base/tracked.h"
 
 // #include "base/waitable_event.h"
@@ skipping 16 matching lines @@
 using testing::Invoke;
 using testing::InvokeWithoutArgs;
 using testing::CreateFunctor;
 using testing::Return;
 using testing::DoAll;
 using testing::Field;
 using chrome_frame_test::TimedMsgLoop;
 
 struct MockUIDelegate : public UIDelegate {
   MOCK_METHOD2(OnNavigationStateChanged, void(int flags,
-      const IPC::NavigationInfo& nav_info));
+      const NavigationInfo& nav_info));
   MOCK_METHOD1(OnUpdateTargetUrl, void(const std::wstring& new_target_url));
   MOCK_METHOD3(OnExtensionInstalled, void(const FilePath& path, void* user_data,
       AutomationMsg_ExtensionResponseValues response));
   MOCK_METHOD1(OnLoad, void(const GURL& url));
   MOCK_METHOD3(OnMessageFromChromeFrame, void(const std::string& message,
       const std::string& origin, const std::string& target));
   MOCK_METHOD3(OnHandleContextMenu, void(HANDLE menu_handle, int align_flags,
-      const IPC::MiniContextMenuParams& params));
+      const MiniContextMenuParams& params));
   MOCK_METHOD1(OnHandleAccelerator, void(const MSG& accel_message));
   MOCK_METHOD1(OnTabbedOut, void(bool reverse));
   MOCK_METHOD1(OnGoToHistoryOffset, void(int offset));
   MOCK_METHOD3(OnOpenURL, void(const GURL& url_to_open, const GURL& referrer,
       int open_disposition));
 };
 
 struct MockProxy : public ChromeProxy {
   MOCK_METHOD1(RemoveBrowsingData, void(int remove_mask));
   MOCK_METHOD3(InstallExtension, void(ChromeProxyDelegate* delegate,
       const FilePath& crx_path, SyncMessageContext* ctx));
   MOCK_METHOD3(LoadExtension, void(ChromeProxyDelegate* delegate,
       const FilePath& path, SyncMessageContext* ctx));
   MOCK_METHOD2(GetEnabledExtensions, void(ChromeProxyDelegate* delegate,
       SyncMessageContext* ctx));
   MOCK_METHOD1(SetProxyConfig, void(const std::string& json_encoded_settings));
 
   MOCK_METHOD2(CreateTab, void(ChromeProxyDelegate* delegate,
-      const IPC::ExternalTabSettings& settings));
+      const ExternalTabSettings& settings));
   MOCK_METHOD3(ConnectTab, void(ChromeProxyDelegate* delegate, HWND hwnd,
       uint64 cookie));
   MOCK_METHOD1(BlockTab, void(uint64 cookie));
 
   MOCK_METHOD4(Tab_PostMessage, void(int tab, const std::string& message,
       const std::string& origin, const std::string& target));
   MOCK_METHOD1(Tab_Reload, void(int tab));
   MOCK_METHOD1(Tab_Stop, void(int tab));
   MOCK_METHOD1(Tab_SaveAs, void(int tab));
   MOCK_METHOD1(Tab_Print, void(int tab));
@@ skipping 59 matching lines @@
   }
 
   void Fire_CompletedCreateTab(bool success, HWND chrome_wnd, HWND tab_window,
                                int tab_handle, int session_id,
                                base::TimeDelta delay) {
     ipc_loop_->PostDelayedTask(FROM_HERE, NewRunnableMethod(delegate_,
         &ChromeProxyDelegate::Completed_CreateTab, success, chrome_wnd,
         tab_window, tab_handle, session_id), delay.InMilliseconds());
   }
 
-  void Fire_TabLoaded(const GURL& url, base::TimeDelta delay) {
-    ipc_loop_->PostDelayedTask(FROM_HERE, NewRunnableMethod(delegate_,
-        &ChromeProxyDelegate::TabLoaded, url), delay.InMilliseconds());
-  }
-
  private:
   ChromeProxyDelegate* delegate_;
   base::Thread ipc_thread_;
   MessageLoop* ipc_loop_;
 };
 
 // We may want the same test with 'real' proxy and mock 'proxy traits'.
 TEST(ExternalTabProxy, CancelledCreateTab) {
   MockUIDelegate ui_delegate;
   StrictMock<MockFactory> factory;
@@ skipping 25 matching lines @@
   CreateTabParams tab_params;
   tab_params.is_incognito = true;
   tab_params.is_widget_mode = false;
   tab_params.url = GURL("http://Xanadu.org");
 
   tab->CreateTab(tab_params, &ui_delegate);
   loop.RunFor(5);
   EXPECT_FALSE(loop.WasTimedOut());
   tab.reset();
 }
-
-// CreateTab with initial url, and the navigate to different url before
-// initialization completes.
-TEST(ExternalTabProxy, NavigateAfterCreate) {
-  MockUIDelegate ui_delegate;
-  StrictMock<MockFactory> factory;
-  scoped_ptr<ExternalTabProxy> tab(new ExternalTabProxy());
-  AsyncEventCreator async_events(tab.get());
-  StrictMock<MockProxy>* proxy = new StrictMock<MockProxy>();
-  TimedMsgLoop loop;
-  tab->set_proxy_factory(&factory);
-  GURL initial_url("http://Xanadu.org");
-  GURL real_url("http://asgard.org");
-
-  EXPECT_CALL(factory, CreateProxy()).WillOnce(Return(proxy));
-  EXPECT_CALL(*proxy, Init(_));
-  EXPECT_CALL(*proxy, AddDelegate(tab.get()))
-      .WillOnce(DoAll(InvokeWithoutArgs(CreateFunctor(&async_events,
-          &AsyncEventCreator::Fire_Connected, proxy,
-          base::TimeDelta::FromMilliseconds(30))),
-      Return(1)));
-
-  EXPECT_CALL(*proxy, CreateTab(tab.get(),
-          Field(&IPC::ExternalTabSettings::initial_url, real_url)))
-      .WillOnce(DoAll(
-      InvokeWithoutArgs(CreateFunctor(&async_events,
-          &AsyncEventCreator::Fire_CompletedCreateTab,
-          true, HWND(0), HWND(0), 7, 0, base::TimeDelta::FromMilliseconds(9))),
-      InvokeWithoutArgs(CreateFunctor(&async_events,
-          &AsyncEventCreator::Fire_TabLoaded, real_url,
-          base::TimeDelta::FromMilliseconds(150)))));
-
-  EXPECT_CALL(ui_delegate, OnLoad(real_url))
-      .WillOnce(QUIT_LOOP(loop));
-
-  EXPECT_CALL(*proxy, RemoveDelegate(_))
-      .WillOnce(DoAll(InvokeWithoutArgs(CreateFunctor(&async_events,
-          &AsyncEventCreator::Fire_Disconnected,
-          base::TimeDelta::FromMilliseconds(0))),
-      Return(0)));
-
-  CreateTabParams tab_params;
-  tab_params.is_incognito = true;
-  tab_params.is_widget_mode = false;
-  tab_params.url = initial_url;
-
-  NavigationConstraintsImpl navigation_constraints;
-
-  tab->CreateTab(tab_params, &ui_delegate);
-  tab->Navigate("http://asgard.org", EmptyString(),
-                &navigation_constraints);
-
-  loop.RunFor(5);
-  EXPECT_FALSE(loop.WasTimedOut());
-  tab.reset();
-}