More non-debug logging in Chrome Frame 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"
@@ skipping 161 matching lines @@
   } else {
     attempts = chrome_frame_test::CloseVisibleWindowsOnAllThreads(
                                                                browser_handle_);
   }
 
   if (attempts > 0) {
     DWORD wait = ::WaitForSingleObject(browser_handle_, 20000);
     if (wait == WAIT_OBJECT_0) {
       browser_handle_.Close();
     } else {
-      DLOG(ERROR) << "WaitForSingleObject returned " << wait;
+      LOG(ERROR) << "WaitForSingleObject returned " << wait;
     }
   } else {
-    DLOG(ERROR) << "No attempts to close browser windows";
+    LOG(ERROR) << "No attempts to close browser windows";
   }
 
   if (browser_handle_.IsValid()) {
     DWORD exit_code = 0;
     if (!::GetExitCodeProcess(browser_handle_, &exit_code) ||
         exit_code == STILL_ACTIVE) {
       LOG(ERROR) << L"Forcefully killing browser process. Exit:" << exit_code;
       base::KillProcess(browser_handle_, 0, true);
     }
     browser_handle_.Close();
@@ skipping 11 matching lines @@
 }
 
 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) {
-  ASSERT_TRUE(LaunchBrowser(browser, page));
   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());
 }
 
 void ChromeFrameTestWithWebServer::SimpleBrowserTest(BrowserKind browser,
     const wchar_t* page) {
   SimpleBrowserTestExpectedResult(browser, page, "OK");
 }
 
 void ChromeFrameTestWithWebServer::VersionTest(BrowserKind browser,
@@ skipping 24 matching lines @@
     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));
 
   EXPECT_TRUE(version_info);
   EXPECT_FALSE(version.empty());
-  EXPECT_TRUE(LaunchBrowser(browser, page));
   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()));
 }
 
 // MockWebServer methods
 void MockWebServer::ExpectAndServeRequest(CFInvocation invocation,
                                           const std::wstring& url) {
   ExpectAndServeRequestWithCardinality(invocation, url, testing::Exactly(1));
 }
 
@@ skipping 66 matching lines @@
   std::string content_type;
   if (file_util::PathExists(file_path) &&
       !file_util::DirectoryExists(file_path)) {
     FilePath mock_http_headers(file_path.value() + L".mock-http-headers");
     if (file_util::PathExists(mock_http_headers)) {
       headers = GetMockHttpHeaders(mock_http_headers);
       content_type = http_utils::GetHttpHeaderFromHeaderList("Content-type",
                                                              headers);
     } else {
       EXPECT_TRUE(net::GetMimeTypeFromFile(file_path, &content_type));
-      DVLOG(1) << "Going to send file (" << WideToUTF8(file_path.value())
-               << ") with content type (" << content_type << ")";
+      VLOG(1) << "Going to send file (" << WideToUTF8(file_path.value())
+              << ") with content type (" << content_type << ")";
       headers = CreateHttpHeaders(invocation, add_no_cache_header,
                                   content_type);
     }
 
     EXPECT_FALSE(headers.empty());
 
     EXPECT_TRUE(file_util::ReadFileToString(file_path, &body))
         << "Could not read file (" << WideToUTF8(file_path.value()) << ")";
     if (invocation.type() == CFInvocation::META_TAG &&
         StartsWithASCII(content_type, "text/html", false)) {
       EXPECT_TRUE(chrome_frame_test::AddCFMetaTag(&body)) << "Could not add "
           << "meta tag to HTML file.";
     }
   } else {
-    DVLOG(1) << "Going to send 404 for non-existent file ("
-             << WideToUTF8(file_path.value()) << ")";
+    VLOG(1) << "Going to send 404 for non-existent file ("
+            << WideToUTF8(file_path.value()) << ")";
     headers = "HTTP/1.1 404 Not Found";
     body = "";
   }
   connection->Send(headers, body);
 }
 
 const wchar_t kPostMessageBasicPage[] = L"postmessage_basic_host.html";
 
 TEST_F(ChromeFrameTestWithWebServer, WidgetModeIE_PostMessageBasic) {
   SimpleBrowserTest(IE, kPostMessageBasicPage);
@@ skipping 636 matching lines @@
   server.web_server()->AddResponse(response);
 
   std::wstring url(server.FormatHttpPath(L"form.html"));
 
   ASSERT_TRUE(LaunchBrowser(IE, url.c_str()));
   loop_.RunFor(kChromeFrameLongNavigationTimeoutInSeconds);
 
   EXPECT_EQ(1, response->get_request_count());
   EXPECT_EQ(1, response->post_request_count());
 }