Merge 31792 - The ChromeFrameAutomationClient class needs to be refcounted as...

chrome_frame/test/chrome_frame_unittests.cc

 // Copyright (c) 2006-2008 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 <windows.h>
 #include <stdarg.h>
 
 // IShellWindows includes.  Unfortunately we can't keep these in
 // alphabetic order since exdisp will bark if some interfaces aren't fully
 // defined.
 #include <mshtml.h>
@@ skipping 883 matching lines @@
 #define QUIT_LOOP_SOON(loop, seconds) testing::InvokeWithoutArgs(\
     CreateFunctor(&loop, &TimedMsgLoop::QuitAfter, seconds))
 
 // We mock ChromeFrameDelegate only. The rest is with real AutomationProxy
 TEST(CFACWithChrome, CreateTooFast) {
   MockCFDelegate cfd;
   TimedMsgLoop loop;
   int timeout = 0;  // Chrome cannot send Hello message so fast.
   const std::wstring profile = L"Adam.N.Epilinter";
 
-  scoped_ptr<ChromeFrameAutomationClient> client;
-  client.reset(new ChromeFrameAutomationClient());
+  scoped_refptr<ChromeFrameAutomationClient> client;
+  client = new ChromeFrameAutomationClient();
 
   EXPECT_CALL(cfd, OnAutomationServerLaunchFailed(AUTOMATION_TIMEOUT,
                                                   testing::_))
       .Times(1)
       .WillOnce(QUIT_LOOP(loop));
 
   EXPECT_TRUE(client->Initialize(&cfd, timeout, false, profile, L"", false));
   loop.RunFor(10);
   client->Uninitialize();
 }
 
 // This test may fail if Chrome take more that 10 seconds (timeout var) to
 // launch. In this case GMock shall print something like "unexpected call to
 // OnAutomationServerLaunchFailed". I'm yet to find out how to specify
 // that this is an unexpected call, and still to execute and action.
 TEST(CFACWithChrome, CreateNotSoFast) {
   MockCFDelegate cfd;
   TimedMsgLoop loop;
   const std::wstring profile = L"Adam.N.Epilinter";
   int timeout = 10000;
 
-  scoped_ptr<ChromeFrameAutomationClient> client;
-  client.reset(new ChromeFrameAutomationClient);
+  scoped_refptr<ChromeFrameAutomationClient> client;
+  client = new ChromeFrameAutomationClient;
 
   EXPECT_CALL(cfd, OnAutomationServerReady())
       .Times(1)
       .WillOnce(QUIT_LOOP(loop));
 
   EXPECT_CALL(cfd, OnAutomationServerLaunchFailed(testing::_, testing::_))
       .Times(0);
 
   EXPECT_TRUE(client->Initialize(&cfd, timeout, false, profile, L"", false));
 
   loop.RunFor(11);
   client->Uninitialize();
-  client.reset(NULL);
+  client = NULL;
 }
 
 MATCHER_P(MsgType, msg_type, "IPC::Message::type()") {
   const IPC::Message& m = arg;
   return (m.type() == msg_type);
 }
 
 MATCHER_P(EqNavigationInfoUrl, url, "IPC::NavigationInfo matcher") {
   if (url.is_valid() && url != arg.url)
     return false;
   // TODO(stevet): other members
   return true;
 }
 
 TEST(CFACWithChrome, NavigateOk) {
   MockCFDelegate cfd;
   TimedMsgLoop loop;
   const std::wstring profile = L"Adam.N.Epilinter";
   const std::string url = "about:version";
   int timeout = 10000;
 
-  scoped_ptr<ChromeFrameAutomationClient> client;
-  client.reset(new ChromeFrameAutomationClient);
+  scoped_refptr<ChromeFrameAutomationClient> client;
+  client = new ChromeFrameAutomationClient;
 
   EXPECT_CALL(cfd, OnAutomationServerReady())
       .WillOnce(testing::IgnoreResult(testing::InvokeWithoutArgs(CreateFunctor(
           client.get(), &ChromeFrameAutomationClient::InitiateNavigation,
           url, std::string(), false))));
 
 //  cfd.SetOnNavigationStateChanged();
   EXPECT_CALL(cfd,
       OnNavigationStateChanged(testing::_, testing::_))
       .Times(testing::AnyNumber());
 
   {
     testing::InSequence s;
 
     EXPECT_CALL(cfd, OnDidNavigate(testing::_, EqNavigationInfoUrl(GURL())))
         .Times(1);
 
     EXPECT_CALL(cfd, OnUpdateTargetUrl(testing::_, testing::_)).Times(1);
 
     EXPECT_CALL(cfd, OnLoad(testing::_, testing::_))
         .Times(1)
         .WillOnce(QUIT_LOOP(loop));
   }
 
   EXPECT_TRUE(client->Initialize(&cfd, timeout, false, profile, L"", false));
   loop.RunFor(10);
   client->Uninitialize();
-  client.reset(NULL);
+  client = NULL;
 }
 
 // Bug: http://b/issue?id=2033644
 TEST(CFACWithChrome, DISABLED_NavigateFailed) {
   MockCFDelegate cfd;
   TimedMsgLoop loop;
   const std::wstring profile = L"Adam.N.Epilinter";
   const std::string url = "http://127.0.0.3:65412/";
   int timeout = 10000;
 
-  scoped_ptr<ChromeFrameAutomationClient> client;
-  client.reset(new ChromeFrameAutomationClient);
+  scoped_refptr<ChromeFrameAutomationClient> client;
+  client = new ChromeFrameAutomationClient;
 
   EXPECT_CALL(cfd, OnAutomationServerReady())
       .WillOnce(testing::IgnoreResult(testing::InvokeWithoutArgs(CreateFunctor(
           client.get(), &ChromeFrameAutomationClient::InitiateNavigation,
           url, std::string(), false))));
 
   EXPECT_CALL(cfd,
     OnNavigationStateChanged(testing::_, testing::_))
     .Times(testing::AnyNumber());
 
   EXPECT_CALL(cfd, OnNavigationFailed(testing::_, testing::_, testing::_))
       .Times(1);
 
   EXPECT_CALL(cfd, OnUpdateTargetUrl(testing::_, testing::_))
       .Times(testing::AnyNumber());
 
   EXPECT_CALL(cfd, OnLoad(testing::_, testing::_))
       .Times(0);
 
   EXPECT_TRUE(client->Initialize(&cfd, timeout, false, profile, L"", false));
 
   loop.RunFor(10);
   client->Uninitialize();
-  client.reset(NULL);
+  client = NULL;
 }
 
 MATCHER_P(EqURLRequest, x, "IPC::AutomationURLRequest matcher") {
   if (arg.url != x.url)
     return false;
   if (arg.method != x.method)
     return false;
   if (arg.referrer != x.referrer)
     return false;
   if (arg.extra_request_headers != x.extra_request_headers)
@@ skipping 10 matching lines @@
   return true;
 }
 
 TEST(CFACWithChrome, UseHostNetworkStack) {
   MockCFDelegate cfd;
   TimedMsgLoop loop;
   const std::wstring profile = L"Adam.N.Epilinter";
   const std::string url = "http://bongo.com";
   int timeout = 10000;
 
-  scoped_ptr<ChromeFrameAutomationClient> client;
-  client.reset(new ChromeFrameAutomationClient);
+  scoped_refptr<ChromeFrameAutomationClient> client;
+  client = new ChromeFrameAutomationClient;
   client->set_use_chrome_network(false);
   cfd.SetAutomationSender(client.get());
 
   EXPECT_CALL(cfd, OnAutomationServerReady())
       .WillOnce(testing::IgnoreResult(testing::InvokeWithoutArgs(CreateFunctor(
           client.get(), &ChromeFrameAutomationClient::InitiateNavigation,
           url, std::string(), false))));
 
   EXPECT_CALL(cfd, OnNavigationStateChanged(testing::_, testing::_))
       .Times(testing::AnyNumber());
@@ skipping 53 matching lines @@
 
   EXPECT_CALL(cfd, OnRequestRead(tab_id, request_id, testing::_))
       .Times(testing::AtMost(1));
 
   bool incognito = true;
   EXPECT_TRUE(client->Initialize(&cfd, timeout, false, profile, L"",
                                  incognito));
 
   loop.RunFor(10);
   client->Uninitialize();
-  client.reset(NULL);
+  client = NULL;
 }
 
 
 // [CFAC] -- uses a ProxyFactory for creation of ChromeFrameAutomationProxy
 // -- uses ChromeFrameAutomationProxy
 // -- uses TabProxy obtained from ChromeFrameAutomationProxy
 // -- uses ChromeFrameDelegate as outgoing interface
 //
 // We mock ProxyFactory to return mock object (MockAutomationProxy) implementing
 // ChromeFrameAutomationProxy interface.
 // Since CFAC uses TabProxy for few calls and TabProxy is not easy mockable,
 // we create 'real' TabProxy but with fake AutomationSender (the one responsible
 // for sending messages over channel).
 // Additionally we have mock implementation ChromeFrameDelagate interface -
 // MockCFDelegate.
 
 // Test fixture, saves typing all of it's members.
 class CFACMockTest : public testing::Test {
  public:
   MockProxyFactory factory_;
   MockCFDelegate   cfd_;
   TimedMsgLoop loop_;
   MockAutomationProxy proxy_;
   scoped_ptr<AutomationHandleTracker> tracker_;
   MockAutomationMessageSender dummy_sender_;
   scoped_refptr<TabProxy> tab_;
-  scoped_ptr<ChromeFrameAutomationClient> client_;  // the victim of all tests
+  // the victim of all tests
+  scoped_refptr<ChromeFrameAutomationClient> client_;
 
   std::wstring profile_;
   int timeout_;
   void* id_;  // Automation server id we are going to return
   int tab_handle_;   // Tab handle. Any non-zero value is Ok.
 
   inline ChromeFrameAutomationProxy* get_proxy() {
     return static_cast<ChromeFrameAutomationProxy*>(&proxy_);
   }
 
@@ skipping 31 matching lines @@
   CFACMockTest() : tracker_(NULL), timeout_(500),
       profile_(L"Adam.N.Epilinter") {
     id_ = reinterpret_cast<void*>(5);
     tab_handle_ = 3;
   }
 
   virtual void SetUp() {
     dummy_sender_.ForwardTo(&proxy_);
     tracker_.reset(new AutomationHandleTracker(&dummy_sender_));
 
-    client_.reset(new ChromeFrameAutomationClient);
+    client_ = new ChromeFrameAutomationClient;
     client_->set_proxy_factory(&factory_);
   }
 };
 
 // Could be implemented as MockAutomationProxy member (we have WithArgs<>!)
 ACTION_P3(HandleCreateTab, tab_handle, external_tab_container, tab_wnd) {
   // arg0 - message
   // arg1 - callback
   // arg2 - key
   CallbackRunner<Tuple3<HWND, HWND, int> >* c =
@@ skipping 309 matching lines @@
     return;
 
   ASSERT_TRUE(mock.web_browser2() != NULL);
 
   loop.RunFor(kChromeFrameLongNavigationTimeoutInSeconds);
 
   mock.Uninitialize();
   chrome_frame_test::CloseAllIEWindows();
 }