src/chrome_frame/test/test_with_web_server.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome_frame/test/test_with_web_server.h"
   6
   7 #include "base/base_paths.h"
   8 #include "base/file_util.h"
   9 #include "base/file_version_info.h"
  10 #include "base/files/memory_mapped_file.h"
  11 #include "base/files/scoped_temp_dir.h"
  12 #include "base/path_service.h"
  13 #include "base/process/kill.h"
  14 #include "base/strings/stringprintf.h"
  15 #include "base/strings/utf_string_conversions.h"
  16 #include "base/test/test_timeouts.h"
  17 #include "base/win/windows_version.h"
  18 #include "chrome/common/chrome_switches.h"
  19 #include "chrome/installer/util/helper.h"
  20 #include "chrome/installer/util/install_util.h"
  21 #include "chrome/installer/util/product.h"
  22 #include "chrome_frame/html_utils.h"
  23 #include "chrome_frame/test/chrome_frame_test_utils.h"
  24 #include "chrome_frame/test/mock_ie_event_sink_actions.h"
  25 #include "chrome_frame/test/mock_ie_event_sink_test.h"
  26 #include "chrome_frame/test/test_scrubber.h"
  27 #include "chrome_frame/utils.h"
  28 #include "net/base/mime_util.h"
  29 #include "net/http/http_util.h"
  30 #include "net/socket/stream_listen_socket.h"
  31
  32 using chrome_frame_test::kChromeFrameLongNavigationTimeout;
  33 using chrome_frame_test::kChromeFrameVeryLongNavigationTimeout;
  34
  35 using testing::_;
  36 using testing::StrCaseEq;
  37
  38 const wchar_t kDocRoot[] = L"chrome_frame\\test\\data";
  39
  40 namespace {
  41
  42 // Helper method for creating the appropriate HTTP response headers.
  43 std::string CreateHttpHeaders(CFInvocation invocation,
  44                               bool add_no_cache_header,
  45                               const std::string& content_type) {
  46   std::ostringstream ss;
  47   ss << "HTTP/1.1 200 OK\r\n"
  48      << "Connection: close\r\n"
  49      << "Content-Type: " << content_type << "\r\n";
  50   if (invocation.type() == CFInvocation::HTTP_HEADER)
  51     ss << "X-UA-Compatible: chrome=1\r\n";
  52   if (add_no_cache_header) {
  53     ss << "Cache-Control: no-cache\r\n";
  54     ss << "Expires: Tue, 15 Nov 1994 08:12:31 GMT\r\n";
  55   }
  56   return ss.str();
  57 }
  58
  59 std::string GetMockHttpHeaders(const base::FilePath& mock_http_headers_path) {
  60   std::string headers;
  61   base::ReadFileToString(mock_http_headers_path, &headers);
  62   return headers;
  63 }
  64
  65 class ChromeFrameTestEnvironment: public testing::Environment {
  66  public:
  67   virtual ~ChromeFrameTestEnvironment() {}
  68   virtual void SetUp() OVERRIDE {
  69     ScopedChromeFrameRegistrar::RegisterDefaults();
  70   }
  71 };
  72
  73 ::testing::Environment* const chrome_frame_env =
  74     ::testing::AddGlobalTestEnvironment(new ChromeFrameTestEnvironment);
  75
  76 }  // namespace
  77
  78 base::FilePath ChromeFrameTestWithWebServer::test_file_path_;
  79 base::FilePath ChromeFrameTestWithWebServer::results_dir_;
  80 base::FilePath ChromeFrameTestWithWebServer::CFInstall_path_;
  81 base::FilePath ChromeFrameTestWithWebServer::CFInstance_path_;
  82 base::ScopedTempDir ChromeFrameTestWithWebServer::temp_dir_;
  83 base::FilePath ChromeFrameTestWithWebServer::chrome_user_data_dir_;
  84 chrome_frame_test::TimedMsgLoop* ChromeFrameTestWithWebServer::loop_;
  85 std::string ChromeFrameTestWithWebServer::local_address_;
  86 testing::StrictMock<MockWebServerListener>*
  87     ChromeFrameTestWithWebServer::listener_mock_;
  88 testing::StrictMock<MockWebServer>* ChromeFrameTestWithWebServer::server_mock_;
  89
  90 ChromeFrameTestWithWebServer::ChromeFrameTestWithWebServer() {
  91 }
  92
  93 // static
  94 void ChromeFrameTestWithWebServer::SetUpTestCase() {
  95   base::FilePath chrome_frame_source_path;
  96   PathService::Get(base::DIR_SOURCE_ROOT, &chrome_frame_source_path);
  97   chrome_frame_source_path = chrome_frame_source_path.Append(
  98       FILE_PATH_LITERAL("chrome_frame"));
  99
 100   test_file_path_ = chrome_frame_source_path
 101       .Append(FILE_PATH_LITERAL("test"))
 102       .Append(FILE_PATH_LITERAL("data"));
 103
 104   results_dir_ = chrome_frame_test::GetTestDataFolder().AppendASCII("dump");
 105
 106   // Copy the CFInstance.js and CFInstall.js files from src\chrome_frame to
 107   // src\chrome_frame\test\data.
 108   base::FilePath CFInstance_src_path;
 109   base::FilePath CFInstall_src_path;
 110
 111   CFInstance_src_path = chrome_frame_source_path.AppendASCII("CFInstance.js");
 112   CFInstance_path_ = test_file_path_.AppendASCII("CFInstance.js");
 113
 114   ASSERT_TRUE(base::CopyFile(CFInstance_src_path, CFInstance_path_));
 115
 116   CFInstall_src_path = chrome_frame_source_path.AppendASCII("CFInstall.js");
 117   CFInstall_path_ = test_file_path_.AppendASCII("CFInstall.js");
 118
 119   ASSERT_TRUE(base::CopyFile(CFInstall_src_path, CFInstall_path_));
 120
 121   loop_ = new chrome_frame_test::TimedMsgLoop();
 122   loop_->set_snapshot_on_timeout(true);
 123   local_address_ = chrome_frame_test::GetLocalIPv4Address();
 124   listener_mock_ = new testing::StrictMock<MockWebServerListener>();
 125   server_mock_ = new testing::StrictMock<MockWebServer>(
 126       1337, ASCIIToWide(local_address_),
 127       chrome_frame_test::GetTestDataFolder());
 128   server_mock_->set_listener(listener_mock_);
 129 }
 130
 131 // static
 132 void ChromeFrameTestWithWebServer::TearDownTestCase() {
 133   delete server_mock_;
 134   server_mock_ = NULL;
 135   delete listener_mock_;
 136   listener_mock_ = NULL;
 137   local_address_.clear();
 138   delete loop_;
 139   loop_ = NULL;
 140   base::DeleteFile(CFInstall_path_, false);
 141   base::DeleteFile(CFInstance_path_, false);
 142   if (temp_dir_.IsValid())
 143     EXPECT_TRUE(temp_dir_.Delete());
 144 }
 145
 146 // static
 147 const base::FilePath&
 148 ChromeFrameTestWithWebServer::GetChromeUserDataDirectory() {
 149   if (!temp_dir_.IsValid()) {
 150     EXPECT_TRUE(temp_dir_.CreateUniqueTempDir());
 151     chrome_user_data_dir_ = temp_dir_.path().AppendASCII("User Data");
 152   }
 153   return chrome_user_data_dir_;
 154 }
 155
 156 void ChromeFrameTestWithWebServer::SetUp() {
 157   // Make sure that we are not accidentally enabling gcf protocol.
 158   SetConfigBool(kAllowUnsafeURLs, false);
 159
 160   server_mock().ClearResults();
 161   server_mock().ExpectAndServeAnyRequests(CFInvocation(CFInvocation::NONE));
 162   server_mock().set_expected_result("OK");
 163 }
 164
 165 void ChromeFrameTestWithWebServer::TearDown() {
 166   CloseBrowser();
 167   loop().RunUntilIdle();
 168   testing::Mock::VerifyAndClear(listener_mock_);
 169   testing::Mock::VerifyAndClear(server_mock_);
 170 }
 171
 172 bool ChromeFrameTestWithWebServer::LaunchBrowser(BrowserKind browser,
 173                                                  const wchar_t* page) {
 174   std::wstring url = page;
 175
 176   // We should resolve the URL only if it is a relative url.
 177   GURL parsed_url(WideToUTF8(page));
 178   if (!parsed_url.has_scheme()) {
 179     url = server_mock().Resolve(page);
 180   }
 181
 182   browser_ = browser;
 183   if (browser == IE) {
 184     browser_handle_.Set(chrome_frame_test::LaunchIE(url));
 185   } else if (browser == CHROME) {
 186     const base::FilePath& user_data_dir = GetChromeUserDataDirectory();
 187     chrome_frame_test::OverrideDataDirectoryForThisTest(user_data_dir.value());
 188     browser_handle_.Set(chrome_frame_test::LaunchChrome(url, user_data_dir));
 189   } else {
 190     NOTREACHED();
 191   }
 192
 193   return browser_handle_.IsValid();
 194 }
 195
 196 void ChromeFrameTestWithWebServer::CloseBrowser() {
 197   if (!browser_handle_.IsValid())
 198     return;
 199
 200   int attempts = 0;
 201   if (browser_ == IE) {
 202     attempts = chrome_frame_test::CloseAllIEWindows();
 203   } else {
 204     attempts = chrome_frame_test::CloseVisibleWindowsOnAllThreads(
 205                                                                browser_handle_);
 206   }
 207
 208   if (attempts > 0) {
 209     DWORD wait = ::WaitForSingleObject(browser_handle_, 20000);
 210     if (wait == WAIT_OBJECT_0) {
 211       browser_handle_.Close();
 212     } else {
 213       LOG(ERROR) << "WaitForSingleObject returned " << wait;
 214     }
 215   } else {
 216     LOG(ERROR) << "No attempts to close browser windows";
 217   }
 218
 219   if (browser_handle_.IsValid()) {
 220     DWORD exit_code = 0;
 221     if (!::GetExitCodeProcess(browser_handle_, &exit_code) ||
 222         exit_code == STILL_ACTIVE) {
 223       LOG(ERROR) << L"Forcefully killing browser process. Exit:" << exit_code;
 224       base::KillProcess(browser_handle_, 0, true);
 225     }
 226     browser_handle_.Close();
 227   }
 228 }
 229
 230 bool ChromeFrameTestWithWebServer::BringBrowserToTop() {
 231   return simulate_input::EnsureProcessInForeground(
 232       GetProcessId(browser_handle_));
 233 }
 234
 235 bool ChromeFrameTestWithWebServer::WaitForTestToComplete(
 236     base::TimeDelta duration) {
 237   loop().RunFor(duration);
 238   return !loop().WasTimedOut();
 239 }
 240
 241 bool ChromeFrameTestWithWebServer::WaitForOnLoad(int milliseconds) {
 242   return false;
 243 }
 244
 245 const wchar_t kPostedResultSubstring[] = L"/writefile/";
 246
 247 void ChromeFrameTestWithWebServer::SimpleBrowserTestExpectedResult(
 248     BrowserKind browser, const wchar_t* page, const char* result) {
 249   if (browser == IE && chrome_frame_test::GetInstalledIEVersion() >= IE_9) {
 250     LOG(INFO) << "Temporarily disabling IE9 web server tests. "
 251                  "See http://crbug.com/143699";
 252     return;
 253   }
 254
 255   int tries = 0;
 256   ExpectAndHandlePostedResult();
 257   // Retry tests that timeout once; see http://crbug.com/96449.
 258   do {
 259     // NOTE: Failed ASSERTs cause this function to exit immediately.
 260     // Don't take a snapshot on the first try.
 261     loop().set_snapshot_on_timeout(tries != 0);
 262     ASSERT_TRUE(LaunchBrowser(browser, page));
 263     if (WaitForTestToComplete(TestTimeouts::action_max_timeout())) {
 264       // The test exited without timing out.  Confirm that the expected response
 265       // was posted and return.
 266       ASSERT_EQ(result, server_mock().posted_result());
 267       break;
 268     }
 269     ASSERT_EQ(std::string(), server_mock().posted_result())
 270         << "Test timed out yet provided a result.";
 271     ASSERT_EQ(0, tries++) << "Failing test due to two timeouts.";
 272     // Close the browser and try a second time.
 273     CloseBrowser();
 274     LOG(ERROR) << "Retrying test once since it timed out.";
 275   } while (true);
 276   loop().set_snapshot_on_timeout(true);
 277 }
 278
 279 void ChromeFrameTestWithWebServer::SimpleBrowserTest(BrowserKind browser,
 280     const wchar_t* page) {
 281   SimpleBrowserTestExpectedResult(browser, page, "OK");
 282 }
 283
 284 void ChromeFrameTestWithWebServer::ExpectAndHandlePostedResult() {
 285   EXPECT_CALL(listener_mock(), OnExpectedResponse())
 286       .WillRepeatedly(QUIT_LOOP_SOON(loop(),
 287                                      base::TimeDelta::FromMilliseconds(100)));
 288   server_mock().ExpectAndHandlePostedResult(CFInvocation(CFInvocation::NONE),
 289                                             kPostedResultSubstring);
 290 }
 291
 292 void ChromeFrameTestWithWebServer::VersionTest(BrowserKind browser,
 293     const wchar_t* page) {
 294   base::FilePath plugin_path;
 295   PathService::Get(base::DIR_MODULE, &plugin_path);
 296   plugin_path = plugin_path.Append(kChromeFrameDllName);
 297
 298   static FileVersionInfo* version_info =
 299       FileVersionInfo::CreateFileVersionInfo(plugin_path);
 300
 301   std::wstring version;
 302   if (version_info)
 303     version = version_info->product_version();
 304
 305   // If we can't find the Chrome Frame DLL in the src tree, we turn to
 306   // the directory where chrome is installed.
 307   if (!version_info) {
 308     BrowserDistribution* dist = BrowserDistribution::GetDistribution();
 309     Version ver_system;
 310     InstallUtil::GetChromeVersion(dist, true, &ver_system);
 311     Version ver_user;
 312     InstallUtil::GetChromeVersion(dist, false, &ver_system);
 313     ASSERT_TRUE(ver_system.IsValid() || ver_user.IsValid());
 314
 315     bool system_install = ver_system.IsValid();
 316     base::FilePath cf_dll_path(installer::GetChromeInstallPath(system_install, dist));
 317     cf_dll_path = cf_dll_path.Append(UTF8ToWide(
 318         ver_system.IsValid() ? ver_system.GetString() : ver_user.GetString()));
 319     cf_dll_path = cf_dll_path.Append(kChromeFrameDllName);
 320     version_info = FileVersionInfo::CreateFileVersionInfo(cf_dll_path);
 321     if (version_info)
 322       version = version_info->product_version();
 323   }
 324
 325   server_mock().set_expected_result(WideToUTF8(version));
 326
 327   EXPECT_TRUE(version_info);
 328   EXPECT_FALSE(version.empty());
 329
 330   SimpleBrowserTestExpectedResult(browser, page, WideToASCII(version).c_str());
 331 }
 332
 333 // MockWebServer methods
 334 void MockWebServer::ExpectAndServeRequest(CFInvocation invocation,
 335                                           const std::wstring& url) {
 336   ExpectAndServeRequestWithCardinality(invocation, url, testing::Exactly(1));
 337 }
 338
 339 void MockWebServer::ExpectAndServeRequestWithCardinality(
 340     CFInvocation invocation, const std::wstring& url,
 341     testing::Cardinality cardinality) {
 342   EXPECT_CALL(*this, Get(_, chrome_frame_test::UrlPathEq(url), _))
 343       .Times(cardinality)
 344       .WillRepeatedly(SendResponse(this, invocation));
 345 }
 346
 347 void MockWebServer::ExpectAndServeRequestAllowCache(CFInvocation invocation,
 348                                                     const std::wstring &url) {
 349   EXPECT_CALL(*this, Get(_, chrome_frame_test::UrlPathEq(url), _))
 350       .WillOnce(SendResponse(this, invocation));
 351 }
 352
 353 void MockWebServer::ExpectAndServeRequestAnyNumberTimes(
 354     CFInvocation invocation, const std::wstring& path_prefix) {
 355   EXPECT_CALL(*this, Get(_, testing::StartsWith(path_prefix), _))
 356       .WillRepeatedly(SendResponse(this, invocation));
 357 }
 358
 359 void MockWebServer::ExpectAndHandlePostedResult(
 360     CFInvocation invocation, const std::wstring& post_suffix) {
 361   EXPECT_CALL(*this, Post(_, testing::HasSubstr(post_suffix), _))
 362       .WillRepeatedly(HandlePostedResponseHelper(this, invocation));
 363 }
 364
 365 void MockWebServer::HandlePostedResponse(
 366     test_server::ConfigurableConnection* connection,
 367     const test_server::Request& request) {
 368   posted_result_ = request.content();
 369   if (listener_ && posted_result_ == expected_result_)
 370     listener_->OnExpectedResponse();
 371   connection->Send("HTTP/1.1 200 OK\r\n", "");
 372 }
 373
 374 void MockWebServer::SendResponseHelper(
 375     test_server::ConfigurableConnection* connection,
 376     const std::wstring& request_uri,
 377     const test_server::Request& request,
 378     CFInvocation invocation,
 379     bool add_no_cache_header) {
 380   static const wchar_t kEchoHeader[] = L"/echoheader?";
 381   if (request_uri.find(kEchoHeader) != std::wstring::npos) {
 382     std::wstring header = request_uri.substr(
 383         wcslen(kEchoHeader),
 384         request_uri.length() - wcslen(kEchoHeader));
 385
 386     std::string header_value = http_utils::GetHttpHeaderFromHeaderList(
 387         WideToUTF8(header), request.headers());
 388     connection->Send(header_value, "");
 389     return;
 390   }
 391   // Convert |request_uri| to a path.
 392   std::wstring path = request_uri;
 393   size_t query_index = request_uri.find(L"?");
 394   if (query_index != std::string::npos) {
 395     path = path.erase(query_index);
 396   }
 397   base::FilePath file_path = root_dir_;
 398   if (path.size())
 399     file_path = file_path.Append(path.substr(1));  // remove first '/'
 400
 401   std::string headers, body;
 402   std::string content_type;
 403   if (base::PathExists(file_path) &&
 404       !base::DirectoryExists(file_path)) {
 405     base::FilePath mock_http_headers(file_path.value() + L".mock-http-headers");
 406     if (base::PathExists(mock_http_headers)) {
 407       headers = GetMockHttpHeaders(mock_http_headers);
 408       content_type = http_utils::GetHttpHeaderFromHeaderList("Content-type",
 409                                                              headers);
 410     } else {
 411       EXPECT_TRUE(net::GetMimeTypeFromFile(file_path, &content_type));
 412       VLOG(1) << "Going to send file (" << WideToUTF8(file_path.value())
 413               << ") with content type (" << content_type << ")";
 414       headers = CreateHttpHeaders(invocation, add_no_cache_header,
 415                                   content_type);
 416     }
 417
 418     EXPECT_FALSE(headers.empty());
 419
 420     EXPECT_TRUE(base::ReadFileToString(file_path, &body))
 421         << "Could not read file (" << WideToUTF8(file_path.value()) << ")";
 422     if (invocation.type() == CFInvocation::META_TAG &&
 423         StartsWithASCII(content_type, "text/html", false)) {
 424       EXPECT_TRUE(chrome_frame_test::AddCFMetaTag(&body)) << "Could not add "
 425           << "meta tag to HTML file.";
 426     }
 427   } else {
 428     VLOG(1) << "Going to send 404 for non-existent file ("
 429             << WideToUTF8(file_path.value()) << ")";
 430     headers = "HTTP/1.1 404 Not Found";
 431     body = "";
 432   }
 433   connection->Send(headers, body);
 434 }
 435
 436 const wchar_t kPostMessageBasicPage[] = L"postmessage_basic_host.html";
 437
 438 TEST_F(ChromeFrameTestWithWebServer, WidgetModeIE_PostMessageBasic) {
 439   SimpleBrowserTest(IE, kPostMessageBasicPage);
 440 }
 441
 442 TEST_F(ChromeFrameTestWithWebServer, FullTabIE_MIMEFilterBasic) {
 443   const wchar_t kMIMEFilterBasicPage[] =
 444       L"chrome_frame_mime_filter_test.html";
 445
 446   // If this test fails for IE8 then it is possible that prebinding is enabled.
 447   // A known workaround is to disable it until CF properly handles it.
 448   //
 449   // HKCU\Software\Microsoft\Internet Explorer\Main
 450   // Value name: EnablePreBinding (REG_DWORD)
 451   // Value: 0
 452   SimpleBrowserTest(IE, kMIMEFilterBasicPage);
 453 }
 454
 455 // Times out: http://crbug.com/163728
 456 TEST_F(ChromeFrameTestWithWebServer, DISABLED_WidgetModeIE_Resize) {
 457   SimpleBrowserTest(IE, L"chrome_frame_resize.html");
 458 }
 459
 460 const wchar_t kNavigateURLAbsolutePage[] =
 461     L"navigateurl_absolute_host.html";
 462
 463 TEST_F(ChromeFrameTestWithWebServer, WidgetModeIE_NavigateURLAbsolute) {
 464   SimpleBrowserTest(IE, kNavigateURLAbsolutePage);
 465 }
 466
 467 const wchar_t kNavigateURLRelativePage[] =
 468     L"navigateurl_relative_host.html";
 469
 470 // Flaky, crbug.com/160497.
 471 TEST_F(ChromeFrameTestWithWebServer,
 472        DISABLED_WidgetModeIE_NavigateURLRelative) {
 473   SimpleBrowserTest(IE, kNavigateURLRelativePage);
 474 }
 475
 476 const wchar_t kNavigateSimpleObjectFocus[] = L"simple_object_focus.html";
 477
 478 TEST_F(ChromeFrameTestWithWebServer, WidgetModeIE_ObjectFocus) {
 479   SimpleBrowserTest(IE, kNavigateSimpleObjectFocus);
 480 }
 481
 482 const wchar_t kiframeBasicPage[] = L"iframe_basic_host.html";
 483
 484
 485 // Flaky, crbug.com/160497.
 486 TEST_F(ChromeFrameTestWithWebServer, DISABLED_WidgetModeIE_iframeBasic) {
 487   SimpleBrowserTest(IE, kiframeBasicPage);
 488 }
 489
 490 const wchar_t kSrcPropertyTestPage[] = L"src_property_host.html";
 491
 492 TEST_F(ChromeFrameTestWithWebServer, WidgetModeIE_SrcProperty) {
 493   SimpleBrowserTest(IE, kSrcPropertyTestPage);
 494 }
 495
 496 const wchar_t kCFInstanceBasicTestPage[] = L"CFInstance_basic_host.html";
 497
 498 TEST_F(ChromeFrameTestWithWebServer, WidgetModeIE_CFInstanceBasic) {
 499   SimpleBrowserTest(IE, kCFInstanceBasicTestPage);
 500 }
 501
 502 const wchar_t kCFISingletonPage[] = L"CFInstance_singleton_host.html";
 503
 504 TEST_F(ChromeFrameTestWithWebServer, WidgetModeIE_CFInstanceSingleton) {
 505   SimpleBrowserTest(IE, kCFISingletonPage);
 506 }
 507
 508 const wchar_t kCFIDelayPage[] = L"CFInstance_delay_host.html";
 509
 510 TEST_F(ChromeFrameTestWithWebServer, WidgetModeIE_CFInstanceDelay) {
 511   SimpleBrowserTest(IE, kCFIDelayPage);
 512 }
 513
 514 const wchar_t kCFIFallbackPage[] = L"CFInstance_fallback_host.html";
 515
 516 TEST_F(ChromeFrameTestWithWebServer, WidgetModeIE_CFInstanceFallback) {
 517   SimpleBrowserTest(IE, kCFIFallbackPage);
 518 }
 519
 520 const wchar_t kCFINoSrcPage[] = L"CFInstance_no_src_host.html";
 521
 522 // Flaky, crbug.com/160497.
 523 TEST_F(ChromeFrameTestWithWebServer, DISABLED_WidgetModeIE_CFInstanceNoSrc) {
 524   SimpleBrowserTest(IE, kCFINoSrcPage);
 525 }
 526
 527 const wchar_t kCFIIfrOnLoadPage[] = L"CFInstance_iframe_onload_host.html";
 528
 529 // disabled since it's unlikely that we care about this case
 530 TEST_F(ChromeFrameTestWithWebServer,
 531        DISABLED_WidgetModeIE_CFInstanceIfrOnLoad) {
 532   SimpleBrowserTest(IE, kCFIIfrOnLoadPage);
 533 }
 534
 535 const wchar_t kCFIZeroSizePage[] = L"CFInstance_zero_size_host.html";
 536
 537 TEST_F(ChromeFrameTestWithWebServer, WidgetModeIE_CFInstanceZeroSize) {
 538   SimpleBrowserTest(IE, kCFIZeroSizePage);
 539 }
 540
 541 const wchar_t kCFIIfrPostPage[] = L"CFInstance_iframe_post_host.html";
 542
 543 TEST_F(ChromeFrameTestWithWebServer, WidgetModeIE_CFInstanceIfrPost) {
 544   SimpleBrowserTest(IE, kCFIIfrPostPage);
 545 }
 546
 547 TEST_F(ChromeFrameTestWithWebServer, WidgetModeChrome_CFInstanceIfrPost) {
 548   SimpleBrowserTest(CHROME, kCFIIfrPostPage);
 549 }
 550
 551 const wchar_t kCFIPostPage[] = L"CFInstance_post_host.html";
 552
 553 TEST_F(ChromeFrameTestWithWebServer, WidgetModeIE_CFInstancePost) {
 554   if (chrome_frame_test::GetInstalledIEVersion() == IE_9) {
 555     LOG(INFO) << "Not running test on Vista/Windows 7 with IE9";
 556     return;
 557   }
 558   SimpleBrowserTest(IE, kCFIPostPage);
 559 }
 560
 561 // This test randomly fails on the ChromeFrame builder.
 562 TEST_F(ChromeFrameTestWithWebServer, WidgetModeChrome_CFInstancePost) {
 563   SimpleBrowserTest(CHROME, kCFIPostPage);
 564 }
 565
 566 const wchar_t kCFIRPCPage[] = L"CFInstance_rpc_host.html";
 567
 568 TEST_F(ChromeFrameTestWithWebServer, WidgetModeIE_CFInstanceRPC) {
 569   if (chrome_frame_test::GetInstalledIEVersion() == IE_9) {
 570     LOG(INFO) << "Not running test on Vista/Windows 7 with IE9";
 571     return;
 572   }
 573   SimpleBrowserTest(IE, kCFIRPCPage);
 574 }
 575
 576 TEST_F(ChromeFrameTestWithWebServer, WidgetModeChrome_CFInstanceRPC) {
 577   SimpleBrowserTest(CHROME, kCFIRPCPage);
 578 }
 579
 580 const wchar_t kCFIRPCInternalPage[] =
 581     L"CFInstance_rpc_internal_host.html";
 582
 583 TEST_F(ChromeFrameTestWithWebServer, WidgetModeIE_CFInstanceRPCInternal) {
 584   if (chrome_frame_test::GetInstalledIEVersion() == IE_9) {
 585     LOG(INFO) << "Not running test on Vista/Windows 7 with IE9";
 586     return;
 587   }
 588   SimpleBrowserTest(IE, kCFIRPCInternalPage);
 589 }
 590
 591 TEST_F(ChromeFrameTestWithWebServer, WidgetModeChrome_CFInstanceRPCInternal) {
 592   SimpleBrowserTest(CHROME, kCFIRPCInternalPage);
 593 }
 594
 595 const wchar_t kCFIDefaultCtorPage[] =
 596     L"CFInstance_default_ctor_host.html";
 597
 598 TEST_F(ChromeFrameTestWithWebServer, WidgetModeIE_CFInstanceDefaultCtor) {
 599   SimpleBrowserTest(IE, kCFIDefaultCtorPage);
 600 }
 601
 602 const wchar_t kCFInstallBasicTestPage[] = L"CFInstall_basic.html";
 603
 604 TEST_F(ChromeFrameTestWithWebServer, FullTabIE_CFInstallBasic) {
 605   SimpleBrowserTest(IE, kCFInstallBasicTestPage);
 606 }
 607
 608 const wchar_t kCFInstallPlaceTestPage[] = L"CFInstall_place.html";
 609
 610 TEST_F(ChromeFrameTestWithWebServer, FullTabIE_CFInstallPlace) {
 611   SimpleBrowserTest(IE, kCFInstallPlaceTestPage);
 612 }
 613
 614 const wchar_t kCFInstallOverlayTestPage[] = L"CFInstall_overlay.html";
 615
 616 TEST_F(ChromeFrameTestWithWebServer, FullTabIE_CFInstallOverlay) {
 617   SimpleBrowserTest(IE, kCFInstallOverlayTestPage);
 618 }
 619
 620 const wchar_t kCFInstallDismissTestPage[] = L"CFInstall_dismiss.html";
 621
 622 TEST_F(ChromeFrameTestWithWebServer, FullTabIE_CFInstallDismiss) {
 623   SimpleBrowserTest(IE, kCFInstallDismissTestPage);
 624 }
 625
 626 const wchar_t kInitializeHiddenPage[] = L"initialize_hidden.html";
 627 // Times out: http://crbug.com/163728
 628 TEST_F(ChromeFrameTestWithWebServer, DISABLED_WidgetModeIE_InitializeHidden) {
 629   SimpleBrowserTest(IE, kInitializeHiddenPage);
 630 }
 631
 632 const wchar_t kFullTabHttpHeaderPage[] = L"chrome_frame_http_header.html";
 633
 634 TEST_F(ChromeFrameTestWithWebServer, FullTabModeIE_CFHttpHeaderBasic) {
 635   SimpleBrowserTest(IE, kFullTabHttpHeaderPage);
 636 }
 637
 638 const wchar_t kFullTabHttpHeaderPageIFrame[] =
 639     L"chrome_frame_http_header_host.html";
 640
 641 TEST_F(ChromeFrameTestWithWebServer, FullTabModeIE_CFHttpHeaderIFrame) {
 642   SimpleBrowserTest(IE, kFullTabHttpHeaderPageIFrame);
 643 }
 644
 645 const wchar_t kFullTabHttpHeaderPageFrameset[] =
 646     L"chrome_frame_http_header_frameset.html";
 647
 648 TEST_F(ChromeFrameTestWithWebServer, FullTabModeIE_CFHttpHeaderFrameSet) {
 649   SimpleBrowserTest(IE, kFullTabHttpHeaderPageFrameset);
 650 }
 651
 652 const wchar_t kVersionPage[] = L"version.html";
 653
 654 // Flaky, crbug.com/160497.
 655 TEST_F(ChromeFrameTestWithWebServer, DISABLED_WidgetModeIE_Version) {
 656   VersionTest(IE, kVersionPage);
 657 }
 658
 659 const wchar_t kEventListenerPage[] = L"event_listener.html";
 660
 661 TEST_F(ChromeFrameTestWithWebServer, WidgetModeIE_EventListener) {
 662   SimpleBrowserTest(IE, kEventListenerPage);
 663 }
 664
 665 const wchar_t kPrivilegedApisPage[] = L"privileged_apis_host.html";
 666
 667 TEST_F(ChromeFrameTestWithWebServer, WidgetModeIE_PrivilegedApis) {
 668   SimpleBrowserTest(IE, kPrivilegedApisPage);
 669 }
 670
 671 const wchar_t kMetaTagPage[] = L"meta_tag.html";
 672 // Flaky, crbug.com/160497.
 673 TEST_F(ChromeFrameTestWithWebServer, DISABLED_FullTabModeIE_MetaTag) {
 674   SimpleBrowserTest(IE, kMetaTagPage);
 675 }
 676
 677 // Times out: http://crbug.com/163728
 678 const wchar_t kCFProtocolPage[] = L"cf_protocol.html";
 679 TEST_F(ChromeFrameTestWithWebServer, DISABLED_FullTabModeIE_CFProtocol) {
 680   // Temporarily enable  gcf: protocol for this test.
 681   SetConfigBool(kAllowUnsafeURLs, true);
 682   SimpleBrowserTest(IE, kCFProtocolPage);
 683   SetConfigBool(kAllowUnsafeURLs, false);
 684 }
 685
 686 const wchar_t kPersistentCookieTest[] =
 687     L"persistent_cookie_test_page.html";
 688 TEST_F(ChromeFrameTestWithWebServer, FullTabModeIE_PersistentCookieTest) {
 689   SimpleBrowserTest(IE, kPersistentCookieTest);
 690 }
 691
 692 const wchar_t kNavigateOutPage[] = L"navigate_out.html";
 693 TEST_F(ChromeFrameTestWithWebServer, FullTabModeIE_NavigateOut) {
 694   SimpleBrowserTest(IE, kNavigateOutPage);
 695 }
 696
 697 const wchar_t kReferrerMainTest[] = L"referrer_main.html";
 698
 699 TEST_F(ChromeFrameTestWithWebServer, FullTabModeIE_ReferrerTest) {
 700   SimpleBrowserTest(IE, kReferrerMainTest);
 701 }
 702
 703 // Times out: http://crbug.com/163728
 704 const wchar_t kSubFrameTestPage[] = L"full_tab_sub_frame_main.html";
 705 TEST_F(ChromeFrameTestWithWebServer, DISABLED_FullTabModeIE_SubFrame) {
 706   SimpleBrowserTest(IE, kSubFrameTestPage);
 707 }
 708
 709 const wchar_t kSubIFrameTestPage[] = L"full_tab_sub_iframe_main.html";
 710 TEST_F(ChromeFrameTestWithWebServer, FullTabModeIE_SubIFrame) {
 711   SimpleBrowserTest(IE, kSubIFrameTestPage);
 712 }
 713
 714 const wchar_t kXMLHttpRequestTestUrl[] =
 715     L"xmlhttprequest_test.html";
 716
 717 // Flaky, crbug.com/160497.
 718 TEST_F(ChromeFrameTestWithWebServer, DISABLED_FullTabModeIE_XHRTest) {
 719   SimpleBrowserTest(IE, kXMLHttpRequestTestUrl);
 720 }
 721
 722 const wchar_t kInstallFlowTestUrl[] =
 723     L"install_flow_test.html";
 724
 725 TEST_F(ChromeFrameTestWithWebServer, FullTabModeIE_InstallFlowTest) {
 726   if (base::win::GetVersion() < base::win::VERSION_VISTA) {
 727     ScopedChromeFrameRegistrar::UnregisterAtPath(
 728         GetChromeFrameBuildPath().value(),
 729         chrome_frame_test::GetTestBedType());
 730
 731     ASSERT_TRUE(LaunchBrowser(IE, kInstallFlowTestUrl));
 732
 733     loop().RunFor(kChromeFrameLongNavigationTimeout);
 734
 735     ScopedChromeFrameRegistrar::RegisterAtPath(
 736         GetChromeFrameBuildPath().value(),
 737         chrome_frame_test::GetTestBedType());
 738
 739     ExpectAndHandlePostedResult();
 740     loop().RunFor(kChromeFrameLongNavigationTimeout);
 741
 742     chrome_frame_test::CloseAllIEWindows();
 743     ASSERT_EQ("OK", server_mock().posted_result());
 744   }
 745 }
 746
 747 const wchar_t kMultipleCFInstancesTestUrl[] =
 748     L"multiple_cf_instances_main.html";
 749
 750 TEST_F(ChromeFrameTestWithWebServer, WidgetModeIE_MultipleCFInstances) {
 751   SimpleBrowserTest(IE, kMultipleCFInstancesTestUrl);
 752 }
 753
 754 const wchar_t kXHRHeaderTestUrl[] =
 755     L"xmlhttprequest_header_test.html";
 756
 757 // Marking as flaky since it occasionally times out. crbug.com/127395.
 758 TEST_F(ChromeFrameTestWithWebServer, DISABLED_FullTabModeIE_XHRHeaderTest) {
 759   SimpleBrowserTest(IE, kXHRHeaderTestUrl);
 760 }
 761
 762 const wchar_t kDeleteCookieTest[] =
 763     L"fulltab_delete_cookie_test.html";
 764
 765 TEST_F(ChromeFrameTestWithWebServer, FullTabModeIE_DeleteCookieTest) {
 766   SimpleBrowserTest(IE, kDeleteCookieTest);
 767 }
 768
 769 const wchar_t kAnchorUrlNavigate[] =
 770     L"fulltab_anchor_url_navigate.html#chrome_frame";
 771
 772 TEST_F(ChromeFrameTestWithWebServer, FullTabModeIE_AnchorUrlNavigateTest) {
 773   SimpleBrowserTest(IE, kAnchorUrlNavigate);
 774 }
 775
 776 // Test whether POST-ing a form from an mshtml page to a CF page will cause
 777 // the request to get reissued.  It should not.
 778 // https://code.google.com/p/chromium/issues/detail?id=143699
 779 TEST_F(ChromeFrameTestWithWebServer, DISABLED_FullTabModeIE_TestPostReissue) {
 780   // The order of pages in this array is assumed to be mshtml, cf, script.
 781   const wchar_t* kPages[] = {
 782     L"full_tab_post_mshtml.html",
 783     L"full_tab_post_target_cf.html",
 784     L"chrome_frame_tester_helpers.js",
 785   };
 786
 787   SimpleWebServerTest server(local_address_, 46664);
 788   server.PopulateStaticFileListT<test_server::FileResponse>(kPages,
 789       arraysize(kPages), GetCFTestFilePath());
 790
 791   ASSERT_TRUE(LaunchBrowser(IE, server.FormatHttpPath(kPages[0]).c_str()));
 792
 793   loop().RunFor(kChromeFrameLongNavigationTimeout);
 794
 795   const test_server::Request* request = NULL;
 796   server.FindRequest("/quit?OK", &request);
 797   ASSERT_TRUE(request != NULL);
 798   EXPECT_EQ("OK", request->arguments());
 799
 800   if (request->arguments().compare("OK") == 0) {
 801     // Check how many requests we got for the cf page.  Also expect it to be
 802     // a POST.
 803     int requests = server.GetRequestCountForPage(kPages[1], "POST");
 804     EXPECT_EQ(1, requests);
 805   }
 806 }
 807
 808 // Test whether following a link from an mshtml page to a CF page will cause
 809 // multiple network requests.  It should not.
 810 // Flaky, crbug.com/160497.
 811 TEST_F(ChromeFrameTestWithWebServer, DISABLED_FullTabModeIE_TestMultipleGet) {
 812   // The order of pages in this array is assumed to be mshtml, cf, script.
 813   const wchar_t* kPages[] = {
 814     L"full_tab_get_mshtml.html",
 815     L"full_tab_get_target_cf.html",
 816     L"chrome_frame_tester_helpers.js",
 817   };
 818
 819   SimpleWebServerTest server(local_address_, 46664);
 820
 821   server.PopulateStaticFileListT<test_server::FileResponse>(kPages,
 822       arraysize(kPages), GetCFTestFilePath());
 823
 824   ASSERT_TRUE(LaunchBrowser(IE, server.FormatHttpPath(kPages[0]).c_str()));
 825
 826   loop().RunFor(kChromeFrameVeryLongNavigationTimeout);
 827
 828   const test_server::Request* request = NULL;
 829   server.FindRequest("/quit?OK", &request);
 830   ASSERT_TRUE(request != NULL);
 831   EXPECT_EQ("OK", request->arguments());
 832
 833   if (request->arguments().compare("OK") == 0) {
 834     // Check how many requests we got for the cf page and check that it was
 835     // a GET.
 836     int requests = server.GetRequestCountForPage(kPages[1], "GET");
 837     EXPECT_EQ(1, requests);
 838   }
 839 }
 840
 841 const wchar_t kSetCookieTest[] =
 842     L"fulltab_set_cookie_test.html";
 843
 844 TEST_F(ChromeFrameTestWithWebServer, FullTabModeIE_SetCookieTest) {
 845   SimpleBrowserTest(IE, kSetCookieTest);
 846 }
 847
 848 const wchar_t kXHRConditionalHeaderTestUrl[] =
 849     L"xmlhttprequest_conditional_header_test.html";
 850
 851 TEST_F(ChromeFrameTestWithWebServer, FullTabModeIE_XHRConditionalHeaderTest) {
 852   SimpleBrowserTest(IE, kXHRConditionalHeaderTestUrl);
 853 }
 854
 855 const wchar_t kWindowCloseTestUrl[] =
 856     L"window_close.html";
 857
 858 TEST_F(ChromeFrameTestWithWebServer, FullTabModeIE_WindowClose) {
 859   SimpleBrowserTest(IE, kWindowCloseTestUrl);
 860 }
 861
 862 std::string GetHeaderValue(const std::string& headers,
 863                            const char* header_name) {
 864   net::HttpUtil::HeadersIterator it(headers.begin(), headers.end(),
 865                                     "\r\n");
 866   while (it.GetNext()) {
 867     if (lstrcmpiA(it.name().c_str(), header_name) == 0) {
 868       return it.values();
 869     }
 870   }
 871   return "";
 872 }
 873
 874 // Specialized implementation of test_server::FileResponse that supports
 875 // adding the request's User-Agent header to the returned document.
 876 // The class also supports $request_id$ which will be replaced with an
 877 // id that's incremented each time the response is sent over a socket.
 878 class UaTemplateFileResponse : public test_server::FileResponse {
 879  public:
 880   typedef test_server::FileResponse SuperClass;
 881
 882   UaTemplateFileResponse(const char* request_path,
 883                          const base::FilePath& file_path)
 884       : test_server::FileResponse(request_path, file_path), request_id_(0) {
 885   }
 886
 887   virtual bool Matches(const test_server::Request& r) const {
 888     bool ret = SuperClass::Matches(r);
 889     if (ret)
 890       ua_ = GetHeaderValue(r.headers(), "User-Agent");
 891     return ret;
 892   }
 893
 894   virtual size_t ContentLength() const {
 895     const char kRequestIdTemplate[] = "$request_id$";
 896     const char kUserAgentTemplate[] = "$UA$";
 897
 898     size_t length = SuperClass::ContentLength();
 899     DCHECK(length);
 900     content_.assign(reinterpret_cast<const char*>(file_->data()),
 901                     file_->length());
 902     size_t i = content_.find(kUserAgentTemplate);
 903     if (i != std::string::npos)
 904       content_.replace(i, arraysize(kUserAgentTemplate) - 1, ua_);
 905     i = content_.find(kRequestIdTemplate);
 906     if (i != std::string::npos) {
 907       content_.replace(i, arraysize(kRequestIdTemplate) - 1,
 908                        base::StringPrintf("%i", request_id_));
 909     }
 910     return content_.length();
 911   }
 912
 913   virtual void WriteContents(net::StreamListenSocket* socket) const {
 914     DCHECK(content_.length());
 915     socket->Send(content_.c_str(), content_.length(), false);
 916     request_id_++;
 917   }
 918
 919  protected:
 920   mutable std::string ua_;
 921   mutable std::string content_;
 922   mutable int request_id_;
 923 };
 924
 925 // This test simulates a URL that on first request returns a document
 926 // that should be rendered in mshtml, then pops up a sign-in page that
 927 // after signing in, refreshes the original page that should then return
 928 // a page that needs to be rendered in GCF.
 929 //
 930 // This test currently fails because GCF does not add the chromeframe header
 931 // to requests that mshtml initiates via IInternetSession::CreateBinding.
 932 TEST_F(ChromeFrameTestWithWebServer, DISABLED_FullTabModeIE_RefreshMshtmlTest) {
 933   const wchar_t* kPages[] = {
 934     L"mshtml_refresh_test.html",
 935     L"mshtml_refresh_test_popup.html",
 936   };
 937
 938   SimpleWebServerTest server(local_address_, 46664);
 939   server.PopulateStaticFileListT<UaTemplateFileResponse>(kPages,
 940       arraysize(kPages), GetCFTestFilePath());
 941
 942   ASSERT_TRUE(LaunchBrowser(IE, server.FormatHttpPath(kPages[0]).c_str()));
 943
 944   loop().RunFor(kChromeFrameLongNavigationTimeout);
 945
 946   test_server::SimpleWebServer* ws = server.web_server();
 947   const test_server::ConnectionList& connections = ws->connections();
 948   test_server::ConnectionList::const_iterator it = connections.begin();
 949   int requests_for_first_page = 0;
 950   for (; it != connections.end(); ++it) {
 951     test_server::Connection* c = (*it);
 952     const test_server::Request& r = c->request();
 953     if (!r.path().empty() &&
 954         ASCIIToWide(r.path().substr(1)).compare(kPages[0]) == 0) {
 955       requests_for_first_page++;
 956       std::string ua(GetHeaderValue(r.headers(), "User-Agent"));
 957       EXPECT_NE(std::string::npos, ua.find("chromeframe"));
 958     }
 959   }
 960   EXPECT_GT(requests_for_first_page, 1);
 961 }
 962
 963 // See bug 36694 for details.  http://crbug.com/36694
 964 TEST_F(ChromeFrameTestWithWebServer, FullTabModeIE_TestDownloadFromForm) {
 965   chrome_frame_test::MockWindowObserver win_observer_mock;
 966   win_observer_mock.WatchWindow("File Download", "");
 967   win_observer_mock.WatchWindow("View Downloads*", "");
 968
 969   // The content of our HTML test page.  This will be returned whenever
 970   // we reply to a GET request.
 971   static const char kHtml[] =
 972       "<html><head>\n"
 973       "<title>ChromeFrame Form Download Test</title>\n"
 974       // To see how this test runs with only IE (no CF in the picture), comment
 975       // out this meta tag.  The outcome of the test should be identical.
 976       "<meta http-equiv=\"X-UA-Compatible\" content=\"chrome=1\" />\n"
 977       "</head>\n"
 978       "<script language=\"javascript\">\n"
 979       "function SubmitForm() {\n"
 980       "  var form = document.forms['myform'];\n"
 981       "  form.action = document.location;\n"
 982       "  form.submit();\n"
 983       "  return true;\n"
 984       "}\n"
 985       "</script>\n"
 986       "<body onload=\"SubmitForm();\">\n"
 987       "<form method=\"post\" action=\"foo.html\" id=\"myform\">\n"
 988       "  <input type=\"hidden\" name=\"Field1\" value=\"myvalue\" />\n"
 989       "  <input type=\"button\" name=\"btn\" value=\"Test Download\" "
 990           "onclick=\"return SubmitForm();\" id=\"Button1\"/>\n"
 991       "</form></body></html>\n";
 992
 993   // The content of our HTML test page.  This will be returned whenever
 994   // we reply to a POST request.
 995   static const char kText[] =
 996       "This is a text file (in case you were wondering).";
 997
 998   // This http response class will return an HTML document that contains
 999   // a form whenever it receives a GET request.  Whenever it gets a POST
1000   // request, it will respond with a text file that needs to be downloaded
1001   // (content-disposition is "attachment").
1002   class CustomResponse : public test_server::ResponseForPath {
1003    public:
1004     explicit CustomResponse(const char* path)
1005       : test_server::ResponseForPath(path), is_post_(false),
1006         post_requests_(0), get_requests_(0) {
1007     }
1008
1009     virtual bool GetContentType(std::string* content_type) const {
1010       DCHECK(!is_post_);
1011       return false;
1012     }
1013
1014     virtual size_t ContentLength() const {
1015       DCHECK(!is_post_);
1016       return sizeof(kHtml) - 1;
1017     }
1018
1019     virtual bool GetCustomHeaders(std::string* headers) const {
1020       if (!is_post_)
1021         return false;
1022       *headers = base::StringPrintf(
1023           "HTTP/1.1 200 OK\r\n"
1024           "Content-Disposition: attachment;filename=\"test.txt\"\r\n"
1025           "Content-Type: application/text\r\n"
1026           "Connection: close\r\n"
1027           "Content-Length: %i\r\n\r\n", sizeof(kText) - 1);
1028       return true;
1029     }
1030
1031     virtual bool Matches(const test_server::Request& r) const {
1032       bool match = __super::Matches(r);
1033       if (match) {
1034         is_post_ = LowerCaseEqualsASCII(r.method().c_str(), "post");
1035       }
1036       return match;
1037     }
1038
1039     virtual void WriteContents(net::StreamListenSocket* socket) const {
1040       if (is_post_) {
1041         socket->Send(kText, sizeof(kText) - 1, false);
1042       } else {
1043         socket->Send(kHtml, sizeof(kHtml) - 1, false);
1044       }
1045     }
1046
1047     virtual void IncrementAccessCounter() {
1048       __super::IncrementAccessCounter();
1049       if (is_post_) {
1050         post_requests_++;
1051       } else {
1052         get_requests_++;
1053       }
1054     }
1055
1056     size_t get_request_count() const {
1057       return get_requests_;
1058     }
1059
1060     size_t post_request_count() const {
1061       return get_requests_;
1062     }
1063
1064    protected:
1065     mutable bool is_post_;
1066     size_t post_requests_;
1067     size_t get_requests_;
1068   };
1069
1070   EXPECT_CALL(win_observer_mock, OnWindowOpen(_))
1071       .Times(testing::AtMost(1))
1072       .WillOnce(chrome_frame_test::DoCloseWindow());
1073
1074   EXPECT_CALL(win_observer_mock, OnWindowClose(_))
1075       .Times(testing::AtMost(1))
1076       .WillOnce(QUIT_LOOP(loop()));
1077
1078   SimpleWebServerTest server(local_address_, 46664);
1079   CustomResponse* response = new CustomResponse("/form.html");
1080   server.web_server()->AddResponse(response);
1081
1082   std::wstring url(server.FormatHttpPath(L"form.html"));
1083
1084   ASSERT_TRUE(LaunchBrowser(IE, url.c_str()));
1085   loop().RunFor(kChromeFrameLongNavigationTimeout);
1086
1087   EXPECT_EQ(1, response->get_request_count());
1088   EXPECT_EQ(1, response->post_request_count());
1089 }
1090
1091 // This test loads a large page and ensures that the full page contents are
1092 // actually loaded via a self-validating HTML page. This is done due to a bug
1093 // whereby the middle of the response stream would sometimes be truncated when
1094 // loading a CF document. See http://crbug.com/178421 for details.
1095 TEST_F(ChromeFrameTestWithWebServer, FullTabModeIE_LargePageLoad) {
1096   const wchar_t kLargePageLoadPage[] =
1097       L"chrome_frame_large_page.html";
1098
1099   SimpleBrowserTest(IE, kLargePageLoadPage);
1100 }