Attempt to fix ChromeFrameTestWithWebServer tests.

chrome_frame/test/automation_client_mock.cc

 // Copyright (c) 2012 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/test/automation_client_mock.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "chrome/common/automation_messages.h"
 #include "chrome_frame/custom_sync_call_context.h"
 #include "chrome_frame/navigation_constraints.h"
 #include "chrome_frame/test/chrome_frame_test_utils.h"
 #include "chrome_frame/test/test_scrubber.h"
 #include "net/base/net_errors.h"
 
 #define GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #include "testing/gmock_mutant.h"
 
 using testing::_;
 using testing::CreateFunctor;
 using testing::Return;
 
 namespace {
 
 #ifndef NDEBUG
-const int kChromeLaunchTimeout = 15;
+const base::TimeDelta kChromeLaunchTimeout = base::TimeDelta::FromSeconds(15);
 #else
-const int kChromeLaunchTimeout = 10;
+const base::TimeDelta kChromeLaunchTimeout = base::TimeDelta::FromSeconds(10);
 #endif
 
 const int kSaneAutomationTimeoutMs = 10 * 1000;
 
 }  // namespace
 
 MATCHER_P(LaunchParamProfileEq, profile_name, "Check for profile name") {
   return arg->profile_name().compare(profile_name) == 0;
 }
 
@@ skipping 185 matching lines @@
       // Often there's another request for the error page
       .Times(testing::Between(1, 2))
       .WillRepeatedly(testing::WithArgs<0>(testing::Invoke(CreateFunctor(&cfd_,
           &MockCFDelegate::Reply, connection_failed))));
 
   EXPECT_CALL(cfd_, OnUpdateTargetUrl(_)).Times(testing::AnyNumber());
   EXPECT_CALL(cfd_, OnLoad(_)).Times(testing::AtMost(1));
 
   EXPECT_CALL(cfd_, OnNavigationFailed(_, GURL(url)))
       .Times(1)
-      .WillOnce(QUIT_LOOP_SOON(loop_, 2));
+      .WillOnce(QUIT_LOOP_SOON(loop_, base::TimeDelta::FromSeconds(2)));
 
   EXPECT_TRUE(client_->Initialize(&cfd_, launch_params_));
 
   loop_.RunFor(kChromeLaunchTimeout);
 }
 
 TEST_F(CFACMockTest, MockedCreateTabOk) {
   int timeout = 500;
   CreateTab();
   SetAutomationServerOk(1);
@@ skipping 18 matching lines @@
   EXPECT_CALL(mock_proxy_, CancelAsync(_)).Times(testing::AnyNumber());
 
   // Here we go!
   GURL empty;
   scoped_refptr<ChromeFrameLaunchParams> clp(new ChromeFrameLaunchParams(
       empty, empty, profile_path_, profile_path_.BaseName().value(), L"",
       false, false, false, false));
   clp->set_launch_timeout(timeout);
   clp->set_version_check(false);
   EXPECT_TRUE(client_->Initialize(&cfd_, clp));
-  loop_.RunFor(10);
+  loop_.RunFor(base::TimeDelta::FromSeconds(10));
 
   EXPECT_CALL(mock_proxy_, ReleaseTabProxy(testing::Eq(tab_handle_))).Times(1);
   client_->Uninitialize();
 }
 
 TEST_F(CFACMockTest, MockedCreateTabFailed) {
   HWND null_wnd = NULL;
   SetAutomationServerOk(1);
 
   EXPECT_CALL(mock_proxy_, server_version()).Times(testing::AnyNumber())
@@ skipping 12 matching lines @@
   Set_CFD_LaunchFailed(AUTOMATION_CREATE_TAB_FAILED);
 
   // Here we go!
   GURL empty;
   scoped_refptr<ChromeFrameLaunchParams> clp(new ChromeFrameLaunchParams(
       empty, empty, profile_path_, profile_path_.BaseName().value(), L"",
       false, false, false, false));
   clp->set_launch_timeout(timeout_);
   clp->set_version_check(false);
   EXPECT_TRUE(client_->Initialize(&cfd_, clp));
-  loop_.RunFor(4);
+  loop_.RunFor(base::TimeDelta::FromSeconds(4));
   client_->Uninitialize();
 }
 
 class TestChromeFrameAutomationProxyImpl
     : public ChromeFrameAutomationProxyImpl {
  public:
   TestChromeFrameAutomationProxyImpl()
         // 1 is an unneeded timeout.
       : ChromeFrameAutomationProxyImpl(
           NULL, AutomationProxy::GenerateChannelID(), 1) {
@@ skipping 10 matching lines @@
 };
 
 TEST_F(CFACMockTest, OnChannelErrorEmpty) {
   TestChromeFrameAutomationProxyImpl proxy;
 
   // No tabs should do nothing yet still not fail either.
   proxy.FakeChannelError();
 }
 
 TEST_F(CFACMockTest, OnChannelError) {
+  const base::TimeDelta loop_duration = base::TimeDelta::FromSeconds(11);

[robertshield, 2012/04/11 17:03:36]

loop_duration -> loop_duration_seconds

[grt (UTC plus 2), 2012/04/11 17:33:08]

I disagree.  That implies that |loop_duration|'s units are seconds, which is not
the case.

   TestChromeFrameAutomationProxyImpl proxy;
   returned_proxy_ = &proxy;
 
   GURL empty;
   scoped_refptr<ChromeFrameLaunchParams> clp(new ChromeFrameLaunchParams(
       empty, empty, profile_path_, profile_path_.BaseName().value(), L"",
       false, false, false, false));
   clp->set_launch_timeout(1);  // Unneeded timeout, but can't be 0.
   clp->set_version_check(false);
 
@@ skipping 11 matching lines @@
   // First, try a single tab and make sure the notification find its way to the
   // Chrome Frame Delegate.
   StrictMock<MockCFDelegate> cfd1;
   scoped_refptr<ChromeFrameAutomationClient> client1;
   client1 = new ChromeFrameAutomationClient;
   client1->set_proxy_factory(&factory_);
 
   EXPECT_CALL(cfd1, OnAutomationServerReady()).WillOnce(QUIT_LOOP(loop_));
   EXPECT_TRUE(client1->Initialize(&cfd1, clp));
   // Wait for OnAutomationServerReady to be called in the UI thread.
-  loop_.RunFor(11);
+  loop_.RunFor(loop_duration);
 
   proxy.FakeChannelError();
   EXPECT_CALL(cfd1, OnChannelError()).WillOnce(QUIT_LOOP(loop_));
   // Wait for OnChannelError to be propagated to delegate from the UI thread.
-  loop_.RunFor(11);
+  loop_.RunFor(loop_duration);
 
   // Add a second tab using a different delegate.
   StrictMock<MockCFDelegate> cfd2;
   scoped_refptr<ChromeFrameAutomationClient> client2;
   client2 = new ChromeFrameAutomationClient;
   client2->set_proxy_factory(&factory_);
 
   EXPECT_CALL(cfd2, OnAutomationServerReady()).WillOnce(QUIT_LOOP(loop_));
   EXPECT_TRUE(client2->Initialize(&cfd2, clp));
   // Wait for OnAutomationServerReady to be called in the UI thread.
-  loop_.RunFor(11);
+  loop_.RunFor(loop_duration);
 
   EXPECT_CALL(cfd1, OnChannelError()).Times(1);
   EXPECT_CALL(cfd2, OnChannelError()).WillOnce(QUIT_LOOP(loop_));
   proxy.FakeChannelError();
   // Wait for OnChannelError to be propagated to delegate from the UI thread.
-  loop_.RunFor(11);
+  loop_.RunFor(loop_duration);
 
   // And now a 3rd tab using the first delegate.
   scoped_refptr<ChromeFrameAutomationClient> client3;
   client3 = new ChromeFrameAutomationClient;
   client3->set_proxy_factory(&factory_);
 
   EXPECT_CALL(cfd1, OnAutomationServerReady()).WillOnce(QUIT_LOOP(loop_));
   EXPECT_TRUE(client3->Initialize(&cfd1, clp));
   // Wait for OnAutomationServerReady to be called in the UI thread.
-  loop_.RunFor(11);
+  loop_.RunFor(loop_duration);
 
   EXPECT_CALL(cfd2, OnChannelError()).Times(1);
   EXPECT_CALL(cfd1, OnChannelError()).Times(2).WillOnce(Return())
       .WillOnce(QUIT_LOOP(loop_));
   proxy.FakeChannelError();
   // Wait for OnChannelError to be propagated to delegate from the UI thread.
-  loop_.RunFor(11);
+  loop_.RunFor(loop_duration);
 
   // Cleanup.
   client1->Uninitialize();
   client2->Uninitialize();
   client3->Uninitialize();
   client1 = NULL;
   client2 = NULL;
   client3 = NULL;
 }
 
@@ skipping 39 matching lines @@
 
   // Here we go!
   GURL empty;
   scoped_refptr<ChromeFrameLaunchParams> launch_params(
       new ChromeFrameLaunchParams(
           GURL("http://www.nonexistent.com"), empty, profile_path_,
           profile_path_.BaseName().value(), L"", false, false, false, false));
   launch_params->set_launch_timeout(timeout);
   launch_params->set_version_check(false);
   EXPECT_TRUE(client_->Initialize(&cfd_, launch_params));
-  loop_.RunFor(10);
+  loop_.RunFor(base::TimeDelta::FromSeconds(10));
 
   EXPECT_CALL(mock_proxy_, ReleaseTabProxy(testing::Eq(tab_handle_))).Times(1);
   client_->Uninitialize();
 }