Attempt to fix ChromeFrameTestWithWebServer tests.

chrome_frame/test/test_with_web_server.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/test_with_web_server.h"
 
 #include "base/base_paths.h"
 #include "base/file_version_info.h"
 #include "base/path_service.h"
 #include "base/stringprintf.h"
 #include "base/test/test_timeouts.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/windows_version.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/installer/util/product.h"
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/helper.h"
 #include "chrome_frame/html_utils.h"
 #include "chrome_frame/utils.h"
 #include "chrome_frame/test/chrome_frame_test_utils.h"
 #include "chrome_frame/test/mock_ie_event_sink_actions.h"
 #include "chrome_frame/test/mock_ie_event_sink_test.h"
 #include "chrome_frame/test/test_scrubber.h"
 #include "net/base/mime_util.h"
 #include "net/http/http_util.h"
 
-using chrome_frame_test::kChromeFrameLongNavigationTimeoutInSeconds;
-using chrome_frame_test::kChromeFrameVeryLongNavigationTimeoutInSeconds;
+using chrome_frame_test::kChromeFrameLongNavigationTimeout;
+using chrome_frame_test::kChromeFrameVeryLongNavigationTimeout;
 
 using testing::_;
 using testing::StrCaseEq;
 
 const wchar_t kDocRoot[] = L"chrome_frame\\test\\data";
 
 namespace {
 
 // Helper method for creating the appropriate HTTP response headers.
 std::string CreateHttpHeaders(CFInvocation invocation,
                               bool add_no_cache_header,
                               const std::string& content_type) {
   std::ostringstream ss;
   ss << "HTTP/1.1 200 OK\r\n"
      << "Connection: close\r\n"
      << "Content-Type: " << content_type << "\r\n";
   if (invocation.type() == CFInvocation::HTTP_HEADER)
     ss << "X-UA-Compatible: chrome=1\r\n";
-  if (add_no_cache_header)
+  if (add_no_cache_header) {
     ss << "Cache-Control: no-cache\r\n";
+    ss << "Expires: Tue, 15 Nov 1994 08:12:31 GMT\r\n";
+  }
   return ss.str();
 }
 
 std::string GetMockHttpHeaders(const FilePath& mock_http_headers_path) {
   std::string headers;
   file_util::ReadFileToString(mock_http_headers_path, &headers);
   return headers;
 }
 
 class ChromeFrameTestEnvironment: public testing::Environment {
  public:
   virtual ~ChromeFrameTestEnvironment() {}
   virtual void SetUp() OVERRIDE {
     ScopedChromeFrameRegistrar::RegisterDefaults();
   }
 };
 
 ::testing::Environment* const chrome_frame_env =
     ::testing::AddGlobalTestEnvironment(new ChromeFrameTestEnvironment);
 
 }  // namespace
 
 FilePath ChromeFrameTestWithWebServer::test_file_path_;
 FilePath ChromeFrameTestWithWebServer::results_dir_;
 FilePath ChromeFrameTestWithWebServer::CFInstall_path_;
 FilePath ChromeFrameTestWithWebServer::CFInstance_path_;
 ScopedTempDir ChromeFrameTestWithWebServer::temp_dir_;
 FilePath ChromeFrameTestWithWebServer::chrome_user_data_dir_;
+chrome_frame_test::TimedMsgLoop* ChromeFrameTestWithWebServer::loop_;
+testing::StrictMock<MockWebServerListener>*
+    ChromeFrameTestWithWebServer::listener_mock_;
+testing::StrictMock<MockWebServer>* ChromeFrameTestWithWebServer::server_mock_;
 
-ChromeFrameTestWithWebServer::ChromeFrameTestWithWebServer()
-    : loop_(),
-      server_mock_(1337, L"127.0.0.1",
-          chrome_frame_test::GetTestDataFolder()) {
+ChromeFrameTestWithWebServer::ChromeFrameTestWithWebServer() {
 }
 
 // static
 void ChromeFrameTestWithWebServer::SetUpTestCase() {
   FilePath chrome_frame_source_path;
   PathService::Get(base::DIR_SOURCE_ROOT, &chrome_frame_source_path);
   chrome_frame_source_path = chrome_frame_source_path.Append(
       FILE_PATH_LITERAL("chrome_frame"));
 
   test_file_path_ = chrome_frame_source_path
       .Append(FILE_PATH_LITERAL("test"))
       .Append(FILE_PATH_LITERAL("data"));
 
   results_dir_ = chrome_frame_test::GetTestDataFolder().AppendASCII("dump");
 
   // Copy the CFInstance.js and CFInstall.js files from src\chrome_frame to
   // src\chrome_frame\test\data.
   FilePath CFInstance_src_path;
   FilePath CFInstall_src_path;
 
   CFInstance_src_path = chrome_frame_source_path.AppendASCII("CFInstance.js");
   CFInstance_path_ = test_file_path_.AppendASCII("CFInstance.js");
 
   ASSERT_TRUE(file_util::CopyFile(CFInstance_src_path, CFInstance_path_));
 
   CFInstall_src_path = chrome_frame_source_path.AppendASCII("CFInstall.js");
   CFInstall_path_ = test_file_path_.AppendASCII("CFInstall.js");
 
   ASSERT_TRUE(file_util::CopyFile(CFInstall_src_path, CFInstall_path_));
+
+  loop_ = new chrome_frame_test::TimedMsgLoop();
+  loop_->set_snapshot_on_timeout(true);
+  listener_mock_ = new testing::StrictMock<MockWebServerListener>();
+  server_mock_ = new testing::StrictMock<MockWebServer>(
+      1337, ASCIIToWide(chrome_frame_test::GetLocalIPv4Address()),
+      chrome_frame_test::GetTestDataFolder());
+  server_mock_->set_listener(listener_mock_);
 }
 
 // static
 void ChromeFrameTestWithWebServer::TearDownTestCase() {
+  delete server_mock_;
+  server_mock_ = NULL;
+  delete listener_mock_;
+  listener_mock_ = NULL;
+  delete loop_;
+  loop_ = NULL;
   file_util::Delete(CFInstall_path_, false);
   file_util::Delete(CFInstance_path_, false);
-  EXPECT_TRUE(temp_dir_.Delete());
+  if (temp_dir_.IsValid())
+    EXPECT_TRUE(temp_dir_.Delete());
 }
 
 // static
 const FilePath& ChromeFrameTestWithWebServer::GetChromeUserDataDirectory() {
   if (!temp_dir_.IsValid()) {
     EXPECT_TRUE(temp_dir_.CreateUniqueTempDir());
     chrome_user_data_dir_ = temp_dir_.path().AppendASCII("User Data");
   }
   return chrome_user_data_dir_;
 }
 
 void ChromeFrameTestWithWebServer::SetUp() {
   // Make sure that we are not accidentally enabling gcf protocol.
   SetConfigBool(kAllowUnsafeURLs, false);
 
-  server_mock_.ExpectAndServeAnyRequests(CFInvocation(CFInvocation::NONE));
-  server_mock_.set_expected_result("OK");
+  server_mock().ClearResults();
+  server_mock().ExpectAndServeAnyRequests(CFInvocation(CFInvocation::NONE));
+  server_mock().set_expected_result("OK");
 }
 
 void ChromeFrameTestWithWebServer::TearDown() {
   CloseBrowser();
+  loop().RunAllPending();
+  testing::Mock::VerifyAndClear(listener_mock_);
+  testing::Mock::VerifyAndClear(server_mock_);
 }
 
 bool ChromeFrameTestWithWebServer::LaunchBrowser(BrowserKind browser,
                                                  const wchar_t* page) {
   std::wstring url = page;
 
   // We should resolve the URL only if it is a relative url.
   GURL parsed_url(WideToUTF8(page));
   if (!parsed_url.has_scheme()) {
-    url = server_mock_.Resolve(page);
+    url = server_mock().Resolve(page);
   }
 
   browser_ = browser;
   if (browser == IE) {
     browser_handle_.Set(chrome_frame_test::LaunchIE(url));
   } else if (browser == CHROME) {
     const FilePath& user_data_dir = GetChromeUserDataDirectory();
     chrome_frame_test::OverrideDataDirectoryForThisTest(user_data_dir.value());
     browser_handle_.Set(chrome_frame_test::LaunchChrome(url, user_data_dir));
   } else {
@@ skipping 35 matching lines @@
     }
     browser_handle_.Close();
   }
 }
 
 bool ChromeFrameTestWithWebServer::BringBrowserToTop() {
   return simulate_input::EnsureProcessInForeground(
       GetProcessId(browser_handle_));
 }
 
-bool ChromeFrameTestWithWebServer::WaitForTestToComplete(int milliseconds) {
-  loop_.RunFor(milliseconds/1000);
-  return true;
+bool ChromeFrameTestWithWebServer::WaitForTestToComplete(
+    base::TimeDelta duration) {
+  loop().RunFor(duration);
+  return !loop().WasTimedOut();
 }
 
 bool ChromeFrameTestWithWebServer::WaitForOnLoad(int milliseconds) {
   return false;
 }
 
 const wchar_t kPostedResultSubstring[] = L"/writefile/";
 
 void ChromeFrameTestWithWebServer::SimpleBrowserTestExpectedResult(
     BrowserKind browser, const wchar_t* page, const char* result) {
-  server_mock_.ExpectAndHandlePostedResult(CFInvocation(CFInvocation::NONE),
-                                           kPostedResultSubstring);
-  ASSERT_TRUE(LaunchBrowser(browser, page));
-  WaitForTestToComplete(TestTimeouts::action_max_timeout_ms());
-  ASSERT_EQ(result, server_mock_.posted_result());
+  int tries = 0;
+  ExpectAndHandlePostedResult();
+  // Retry tests that timeout once; see http://crbug.com/96449.
+  do {
+    // Don't take a snapshot on the first try.
+    loop().set_snapshot_on_timeout(tries != 0);
+    ASSERT_TRUE(LaunchBrowser(browser, page));
+    if (WaitForTestToComplete(TestTimeouts::action_max_timeout())) {
+      // The test exited without timing out.  Confirm that the expected response
+      // was posted and return.
+      ASSERT_EQ(result, server_mock().posted_result());
+      break;
+    }
+    ASSERT_EQ(std::string(), server_mock().posted_result())
+        << "Test timed out yet provided a result.";
+    ASSERT_EQ(0, tries++) << "Test timed out twice.";

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

Please explicitly mark this with a comment as the expected exit point from the
loop when we time out twice.

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

Done.

+    // Close the browser and try a second time.
+    CloseBrowser();
+    LOG(ERROR) << "Retrying test once since it timed out.";
+  } while (true);
+  loop().set_snapshot_on_timeout(true);
 }
 
 void ChromeFrameTestWithWebServer::SimpleBrowserTest(BrowserKind browser,
     const wchar_t* page) {
   SimpleBrowserTestExpectedResult(browser, page, "OK");
 }
 
+void ChromeFrameTestWithWebServer::ExpectAndHandlePostedResult() {
+  EXPECT_CALL(listener_mock(), OnExpectedResponse())
+      .WillRepeatedly(QUIT_LOOP_SOON(loop(),
+                                     base::TimeDelta::FromMilliseconds(100)));
+  server_mock().ExpectAndHandlePostedResult(CFInvocation(CFInvocation::NONE),
+                                            kPostedResultSubstring);
+}
+
 void ChromeFrameTestWithWebServer::VersionTest(BrowserKind browser,
     const wchar_t* page) {
   FilePath plugin_path;
   PathService::Get(base::DIR_MODULE, &plugin_path);
   plugin_path = plugin_path.Append(kChromeFrameDllName);
 
   static FileVersionInfo* version_info =
       FileVersionInfo::CreateFileVersionInfo(plugin_path);
 
   std::wstring version;
@@ skipping 11 matching lines @@
     bool system_install = ver_system.get() ? true : false;
     FilePath cf_dll_path(installer::GetChromeInstallPath(system_install, dist));
     cf_dll_path = cf_dll_path.Append(UTF8ToWide(
         ver_system.get() ? ver_system->GetString() : ver_user->GetString()));
     cf_dll_path = cf_dll_path.Append(kChromeFrameDllName);
     version_info = FileVersionInfo::CreateFileVersionInfo(cf_dll_path);
     if (version_info)
       version = version_info->product_version();
   }
 
-  server_mock_.set_expected_result(WideToUTF8(version));
+  server_mock().set_expected_result(WideToUTF8(version));
 
   EXPECT_TRUE(version_info);
   EXPECT_FALSE(version.empty());
-  server_mock_.ExpectAndHandlePostedResult(CFInvocation(CFInvocation::NONE),
-                                           kPostedResultSubstring);
-  EXPECT_TRUE(LaunchBrowser(browser, page));
-  WaitForTestToComplete(TestTimeouts::action_max_timeout_ms());
-  ASSERT_EQ(version, UTF8ToWide(server_mock_.posted_result()));
+
+  SimpleBrowserTestExpectedResult(browser, page, WideToASCII(version).c_str());
 }
 
 // MockWebServer methods
 void MockWebServer::ExpectAndServeRequest(CFInvocation invocation,
                                           const std::wstring& url) {
   ExpectAndServeRequestWithCardinality(invocation, url, testing::Exactly(1));
 }
 
 void MockWebServer::ExpectAndServeRequestWithCardinality(
     CFInvocation invocation, const std::wstring& url,
@@ skipping 18 matching lines @@
 void MockWebServer::ExpectAndHandlePostedResult(
     CFInvocation invocation, const std::wstring& post_suffix) {
   EXPECT_CALL(*this, Post(_, testing::HasSubstr(post_suffix), _))
       .WillRepeatedly(HandlePostedResponseHelper(this, invocation));
 }
 
 void MockWebServer::HandlePostedResponse(
     test_server::ConfigurableConnection* connection,
     const test_server::Request& request) {
   posted_result_ = request.content();
-  if (posted_result_ == expected_result_) {
-    MessageLoop::current()->PostDelayedTask(FROM_HERE,
-                                            MessageLoop::QuitClosure(),
-                                            100);
-  }
+  if (listener_ && posted_result_ == expected_result_)
+    listener_->OnExpectedResponse();
   connection->Send("HTTP/1.1 200 OK\r\n", "");
 }
 
 void MockWebServer::SendResponseHelper(
     test_server::ConfigurableConnection* connection,
     const std::wstring& request_uri,
     const test_server::Request& request,
     CFInvocation invocation,
     bool add_no_cache_header) {
   static const wchar_t kEchoHeader[] = L"/echoheader?";
@@ skipping 96 matching lines @@
 }
 
 const wchar_t kiframeBasicPage[] = L"iframe_basic_host.html";
 
 TEST_F(ChromeFrameTestWithWebServer, WidgetModeIE_iframeBasic) {
   SimpleBrowserTest(IE, kiframeBasicPage);
 }
 
 const wchar_t kSrcPropertyTestPage[] = L"src_property_host.html";
 
-TEST_F(ChromeFrameTestWithWebServer, DISABLED_WidgetModeIE_SrcProperty) {
+TEST_F(ChromeFrameTestWithWebServer, WidgetModeIE_SrcProperty) {
   SimpleBrowserTest(IE, kSrcPropertyTestPage);
 }
 
 const wchar_t kCFInstanceBasicTestPage[] = L"CFInstance_basic_host.html";
 
 TEST_F(ChromeFrameTestWithWebServer, WidgetModeIE_CFInstanceBasic) {
   SimpleBrowserTest(IE, kCFInstanceBasicTestPage);
 }
 
 const wchar_t kCFISingletonPage[] = L"CFInstance_singleton_host.html";
 
 TEST_F(ChromeFrameTestWithWebServer, WidgetModeIE_CFInstanceSingleton) {
   SimpleBrowserTest(IE, kCFISingletonPage);
 }
 
 const wchar_t kCFIDelayPage[] = L"CFInstance_delay_host.html";
 
-TEST_F(ChromeFrameTestWithWebServer, DISABLED_WidgetModeIE_CFInstanceDelay) {
+TEST_F(ChromeFrameTestWithWebServer, WidgetModeIE_CFInstanceDelay) {
   SimpleBrowserTest(IE, kCFIDelayPage);
 }
 
 const wchar_t kCFIFallbackPage[] = L"CFInstance_fallback_host.html";
 
-// http://crbug.com/37088
-TEST_F(ChromeFrameTestWithWebServer, DISABLED_WidgetModeIE_CFInstanceFallback) {
+TEST_F(ChromeFrameTestWithWebServer, WidgetModeIE_CFInstanceFallback) {
   SimpleBrowserTest(IE, kCFIFallbackPage);
 }
 
 const wchar_t kCFINoSrcPage[] = L"CFInstance_no_src_host.html";
 
 TEST_F(ChromeFrameTestWithWebServer, WidgetModeIE_CFInstanceNoSrc) {
   SimpleBrowserTest(IE, kCFINoSrcPage);
 }
 
 const wchar_t kCFIIfrOnLoadPage[] = L"CFInstance_iframe_onload_host.html";
 
 // disabled since it's unlikely that we care about this case
 TEST_F(ChromeFrameTestWithWebServer,
        DISABLED_WidgetModeIE_CFInstanceIfrOnLoad) {
   SimpleBrowserTest(IE, kCFIIfrOnLoadPage);
 }
 
 const wchar_t kCFIZeroSizePage[] = L"CFInstance_zero_size_host.html";
 
 TEST_F(ChromeFrameTestWithWebServer, WidgetModeIE_CFInstanceZeroSize) {
   SimpleBrowserTest(IE, kCFIZeroSizePage);
 }
 
 const wchar_t kCFIIfrPostPage[] = L"CFInstance_iframe_post_host.html";
 
-// http://crbug.com/32321
-TEST_F(ChromeFrameTestWithWebServer, DISABLED_WidgetModeIE_CFInstanceIfrPost) {
+TEST_F(ChromeFrameTestWithWebServer, WidgetModeIE_CFInstanceIfrPost) {
   SimpleBrowserTest(IE, kCFIIfrPostPage);
 }
 
 TEST_F(ChromeFrameTestWithWebServer, WidgetModeChrome_CFInstanceIfrPost) {
   SimpleBrowserTest(CHROME, kCFIIfrPostPage);
 }
 
 const wchar_t kCFIPostPage[] = L"CFInstance_post_host.html";
 
 TEST_F(ChromeFrameTestWithWebServer, WidgetModeIE_CFInstancePost) {
   if (chrome_frame_test::GetInstalledIEVersion() == IE_9) {
     LOG(INFO) << "Not running test on Vista/Windows 7 with IE9";
     return;
   }
   SimpleBrowserTest(IE, kCFIPostPage);
 }
 
 // This test randomly fails on the ChromeFrame builder.
 TEST_F(ChromeFrameTestWithWebServer, WidgetModeChrome_CFInstancePost) {
   SimpleBrowserTest(CHROME, kCFIPostPage);
 }
 
 const wchar_t kCFIRPCPage[] = L"CFInstance_rpc_host.html";
 
-// This test consistently times out in debug builds; see http://crbug.com/112599
-#ifndef NDEBUG
-#define MAYBE_WidgetModeIE_CFInstanceRPC DISABLED_WidgetModeIE_CFInstanceRPC
-#else
-#define MAYBE_WidgetModeIE_CFInstanceRPC WidgetModeIE_CFInstanceRPC
-#endif
-
-TEST_F(ChromeFrameTestWithWebServer, MAYBE_WidgetModeIE_CFInstanceRPC) {
+TEST_F(ChromeFrameTestWithWebServer, WidgetModeIE_CFInstanceRPC) {
   if (chrome_frame_test::GetInstalledIEVersion() == IE_9) {
     LOG(INFO) << "Not running test on Vista/Windows 7 with IE9";
     return;
   }
   SimpleBrowserTest(IE, kCFIRPCPage);
 }
 
 TEST_F(ChromeFrameTestWithWebServer, WidgetModeChrome_CFInstanceRPC) {
   SimpleBrowserTest(CHROME, kCFIRPCPage);
 }
@@ skipping 139 matching lines @@
     L"install_flow_test.html";
 
 TEST_F(ChromeFrameTestWithWebServer, FullTabModeIE_InstallFlowTest) {
   if (base::win::GetVersion() < base::win::VERSION_VISTA) {
     ScopedChromeFrameRegistrar::UnregisterAtPath(
         GetChromeFrameBuildPath().value(),
         chrome_frame_test::GetTestBedType());
 
     ASSERT_TRUE(LaunchBrowser(IE, kInstallFlowTestUrl));
 
-    loop_.RunFor(kChromeFrameLongNavigationTimeoutInSeconds);
+    loop().RunFor(kChromeFrameLongNavigationTimeout);
 
     ScopedChromeFrameRegistrar::RegisterAtPath(
         GetChromeFrameBuildPath().value(),
         chrome_frame_test::GetTestBedType());
 
-    server_mock_.ExpectAndHandlePostedResult(CFInvocation(CFInvocation::NONE),
-                                             kPostedResultSubstring);
-    loop_.RunFor(kChromeFrameLongNavigationTimeoutInSeconds);
+    ExpectAndHandlePostedResult();
+    loop().RunFor(kChromeFrameLongNavigationTimeout);
 
     chrome_frame_test::CloseAllIEWindows();
-    ASSERT_EQ("OK", server_mock_.posted_result());
+    ASSERT_EQ("OK", server_mock().posted_result());
   }
 }
 
 const wchar_t kMultipleCFInstancesTestUrl[] =
     L"multiple_cf_instances_main.html";
 
 TEST_F(ChromeFrameTestWithWebServer, WidgetModeIE_MultipleCFInstances) {
   SimpleBrowserTest(IE, kMultipleCFInstancesTestUrl);
 }
 
@@ skipping 27 matching lines @@
     L"full_tab_post_target_cf.html",
     L"chrome_frame_tester_helpers.js",
   };
 
   SimpleWebServerTest server(46664);
   server.PopulateStaticFileListT<test_server::FileResponse>(kPages,
       arraysize(kPages), GetCFTestFilePath());
 
   ASSERT_TRUE(LaunchBrowser(IE, server.FormatHttpPath(kPages[0]).c_str()));
 
-  loop_.RunFor(kChromeFrameLongNavigationTimeoutInSeconds);
+  loop().RunFor(kChromeFrameLongNavigationTimeout);
 
   const test_server::Request* request = NULL;
   server.FindRequest("/quit?OK", &request);
   ASSERT_TRUE(request != NULL);
   EXPECT_EQ("OK", request->arguments());
 
   if (request->arguments().compare("OK") == 0) {
     // Check how many requests we got for the cf page.  Also expect it to be
     // a POST.
     int requests = server.GetRequestCountForPage(kPages[1], "POST");
@@ skipping 11 matching lines @@
     L"chrome_frame_tester_helpers.js",
   };
 
   SimpleWebServerTest server(46664);
 
   server.PopulateStaticFileListT<test_server::FileResponse>(kPages,
       arraysize(kPages), GetCFTestFilePath());
 
   ASSERT_TRUE(LaunchBrowser(IE, server.FormatHttpPath(kPages[0]).c_str()));
 
-  loop_.RunFor(kChromeFrameVeryLongNavigationTimeoutInSeconds);
+  loop().RunFor(kChromeFrameVeryLongNavigationTimeout);
 
   const test_server::Request* request = NULL;
   server.FindRequest("/quit?OK", &request);
   ASSERT_TRUE(request != NULL);
   EXPECT_EQ("OK", request->arguments());
 
   if (request->arguments().compare("OK") == 0) {
     // Check how many requests we got for the cf page and check that it was
     // a GET.
     int requests = server.GetRequestCountForPage(kPages[1], "GET");
@@ skipping 11 matching lines @@
 const wchar_t kXHRConditionalHeaderTestUrl[] =
     L"xmlhttprequest_conditional_header_test.html";
 
 TEST_F(ChromeFrameTestWithWebServer, FullTabModeIE_XHRConditionalHeaderTest) {
   SimpleBrowserTest(IE, kXHRConditionalHeaderTestUrl);
 }
 
 const wchar_t kWindowCloseTestUrl[] =
     L"window_close.html";
 
-// http://code.google.com/p/chromium/issues/detail?id=111074
-TEST_F(ChromeFrameTestWithWebServer, DISABLED_FullTabModeIE_WindowClose) {
+TEST_F(ChromeFrameTestWithWebServer, FullTabModeIE_WindowClose) {
   SimpleBrowserTest(IE, kWindowCloseTestUrl);
 }
 
 std::string GetHeaderValue(const std::string& headers,
                            const char* header_name) {
   net::HttpUtil::HeadersIterator it(headers.begin(), headers.end(),
                                     "\r\n");
   while (it.GetNext()) {
     if (lstrcmpiA(it.name().c_str(), header_name) == 0) {
       return it.values();
@@ skipping 64 matching lines @@
     L"mshtml_refresh_test.html",
     L"mshtml_refresh_test_popup.html",
   };
 
   SimpleWebServerTest server(46664);
   server.PopulateStaticFileListT<UaTemplateFileResponse>(kPages,
       arraysize(kPages), GetCFTestFilePath());
 
   ASSERT_TRUE(LaunchBrowser(IE, server.FormatHttpPath(kPages[0]).c_str()));
 
-  loop_.RunFor(kChromeFrameLongNavigationTimeoutInSeconds);
+  loop().RunFor(kChromeFrameLongNavigationTimeout);
 
   test_server::SimpleWebServer* ws = server.web_server();
   const test_server::ConnectionList& connections = ws->connections();
   test_server::ConnectionList::const_iterator it = connections.begin();
   int requests_for_first_page = 0;
   for (; it != connections.end(); ++it) {
     test_server::Connection* c = (*it);
     const test_server::Request& r = c->request();
     if (!r.path().empty() &&
         ASCIIToWide(r.path().substr(1)).compare(kPages[0]) == 0) {
@@ skipping 111 matching lines @@
     size_t post_requests_;
     size_t get_requests_;
   };
 
   EXPECT_CALL(win_observer_mock, OnWindowOpen(_))
       .Times(testing::AtMost(1))
       .WillOnce(chrome_frame_test::DoCloseWindow());
 
   EXPECT_CALL(win_observer_mock, OnWindowClose(_))
       .Times(testing::AtMost(1))
-      .WillOnce(QUIT_LOOP(loop_));
+      .WillOnce(QUIT_LOOP(loop()));
 
   SimpleWebServerTest server(46664);
   CustomResponse* response = new CustomResponse("/form.html");
   server.web_server()->AddResponse(response);
 
   std::wstring url(server.FormatHttpPath(L"form.html"));
 
   ASSERT_TRUE(LaunchBrowser(IE, url.c_str()));
-  loop_.RunFor(kChromeFrameLongNavigationTimeoutInSeconds);
+  loop().RunFor(kChromeFrameLongNavigationTimeout);
 
   EXPECT_EQ(1, response->get_request_count());
   EXPECT_EQ(1, response->post_request_count());
 }