Expose a static configuration value for the host to use for URLRequestTestHTTP tests.

net/url_request/url_request_unittest.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 "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <shlobj.h>
 #include <windows.h>
 #endif
@@ skipping 46 matching lines @@
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 using base::Time;
 
 namespace net {
 
 namespace {
 
+// A subclass of TestServer that uses a statically-configured hostname. This is
+// to work around mysterious failures in chrome_frame_net_tests. See:
+// http://crbug.com/114369
+class LocalHttpServer : public TestServer {

[eroman, 2012/02/16 02:41:00]

nit: I suggest calling LocalHttpTestServer

[erikwright (departed), 2012/02/16 16:04:13]

Done.

+ public:
+  explicit LocalHttpServer(const FilePath& document_root)
+      : TestServer(TestServer::TYPE_HTTP,
+                   url_request_test_http_host(),
+                   document_root) {}
+  LocalHttpServer()
+      : TestServer(TestServer::TYPE_HTTP,
+                   url_request_test_http_host(),
+                   FilePath()) {}
+};
+
 const string16 kChrome(ASCIIToUTF16("chrome"));
 const string16 kSecret(ASCIIToUTF16("secret"));
 const string16 kUser(ASCIIToUTF16("user"));
 
 base::StringPiece TestNetResourceProvider(int key) {
   return "header";
 }
 
 // Do a case-insensitive search through |haystack| for |needle|.
 bool ContainsString(const std::string& haystack, const char* needle) {
@@ skipping 311 matching lines @@
 
  protected:
   TestNetworkDelegate default_network_delegate_;  // must outlive URLRequest
   scoped_refptr<TestURLRequestContext> default_context_;
   URLRequestJobFactory job_factory_;
 };
 
 class URLRequestTestHTTP : public URLRequestTest {
  public:
   URLRequestTestHTTP()
-      : test_server_(TestServer::TYPE_HTTP,
-                     FilePath(FILE_PATH_LITERAL(
+      : test_server_(FilePath(FILE_PATH_LITERAL(
                                   "net/data/url_request_unittest"))) {
   }
 
  protected:
   // Requests |redirect_url|, which must return a HTTP 3xx redirect.
   // |request_method| is the method to use for the initial request.
   // |redirect_method| is the method that is expected to be used for the second
   // request, after redirection.
   // If |include_data| is true, data is uploaded with the request.  The
   // response body is expected to match it exactly, if and only if
@@ skipping 89 matching lines @@
     ASSERT_EQ(1, d->response_started_count()) << "request failed: " <<
         (int) r->status().status() << ", os error: " << r->status().error();
 
     EXPECT_FALSE(d->received_data_before_response());
 
     ASSERT_EQ(strlen(expected_data), static_cast<size_t>(d->bytes_received()));
     EXPECT_EQ(0, memcmp(d->data_received().c_str(), expected_data,
                         strlen(expected_data)));
   }
 
-  TestServer test_server_;
+  LocalHttpServer test_server_;
 };
 
 // In this unit test, we're using the HTTPTestServer as a proxy server and
 // issuing a CONNECT request with the magic host name "www.redirect.com".
 // The HTTPTestServer will return a 302 response, which we should not
 // follow.
 TEST_F(URLRequestTestHTTP, ProxyTunnelRedirectTest) {
   ASSERT_TRUE(test_server_.Start());
 
   TestNetworkDelegate network_delegate;  // must outlive URLRequest
@@ skipping 1972 matching lines @@
 
     EXPECT_TRUE(d.data_received().find("user2/secret") != std::string::npos);
 
     // Make sure we sent the cookie in the restarted transaction.
     EXPECT_TRUE(d.data_received().find("Cookie: got_challenged=true")
         != std::string::npos);
   }
 }
 
 TEST_F(URLRequestTest, DelayedCookieCallback) {
-  TestServer test_server(TestServer::TYPE_HTTP, FilePath());
+  LocalHttpServer test_server;
   ASSERT_TRUE(test_server.Start());
 
   scoped_refptr<URLRequestContext> context(new TestURLRequestContext());
   scoped_refptr<DelayedCookieMonster> delayed_cm =
       new DelayedCookieMonster();
   scoped_refptr<CookieStore> cookie_store = delayed_cm;
   context->set_cookie_store(delayed_cm);
 
   // Set up a cookie.
   {
@@ skipping 16 matching lines @@
     MessageLoop::current()->Run();
 
     EXPECT_TRUE(d.data_received().find("CookieToNotSend=1")
                 != std::string::npos);
     EXPECT_EQ(0, d.blocked_get_cookies_count());
     EXPECT_EQ(0, d.blocked_set_cookie_count());
   }
 }
 
 TEST_F(URLRequestTest, DoNotSendCookies) {
-  TestServer test_server(TestServer::TYPE_HTTP, FilePath());
+  LocalHttpServer test_server;
   ASSERT_TRUE(test_server.Start());
 
   // Set up a cookie.
   {
     TestDelegate d;
     URLRequest req(test_server.GetURL("set-cookie?CookieToNotSend=1"), &d);
     req.set_context(default_context_);
     req.Start();
     MessageLoop::current()->Run();
     EXPECT_EQ(0, d.blocked_get_cookies_count());
@@ skipping 26 matching lines @@
     EXPECT_TRUE(d.data_received().find("Cookie: CookieToNotSend=1")
                 == std::string::npos);
 
     // LOAD_DO_NOT_SEND_COOKIES does not trigger OnGetCookies.
     EXPECT_EQ(0, d.blocked_get_cookies_count());
     EXPECT_EQ(0, d.blocked_set_cookie_count());
   }
 }
 
 TEST_F(URLRequestTest, DoNotSaveCookies) {
-  TestServer test_server(TestServer::TYPE_HTTP, FilePath());
+  LocalHttpServer test_server;
   ASSERT_TRUE(test_server.Start());
 
   // Set up a cookie.
   {
     TestDelegate d;
     URLRequest req(test_server.GetURL("set-cookie?CookieToNotUpdate=2"), &d);
     req.set_context(default_context_);
     req.Start();
     MessageLoop::current()->Run();
 
@@ skipping 32 matching lines @@
     EXPECT_TRUE(d.data_received().find("CookieToNotUpdate=2")
                 != std::string::npos);
 
     EXPECT_EQ(0, d.blocked_get_cookies_count());
     EXPECT_EQ(0, d.blocked_set_cookie_count());
     EXPECT_EQ(0, d.set_cookie_count());
   }
 }
 
 TEST_F(URLRequestTest, DoNotSendCookies_ViaPolicy) {
-  TestServer test_server(TestServer::TYPE_HTTP, FilePath());
+  LocalHttpServer test_server;
   ASSERT_TRUE(test_server.Start());
 
   // Set up a cookie.
   {
     TestDelegate d;
     URLRequest req(test_server.GetURL("set-cookie?CookieToNotSend=1"), &d);
     req.set_context(default_context_);
     req.Start();
     MessageLoop::current()->Run();
 
@@ skipping 27 matching lines @@
 
     EXPECT_TRUE(d.data_received().find("Cookie: CookieToNotSend=1")
                 == std::string::npos);
 
     EXPECT_EQ(1, d.blocked_get_cookies_count());
     EXPECT_EQ(0, d.blocked_set_cookie_count());
   }
 }
 
 TEST_F(URLRequestTest, DoNotSaveCookies_ViaPolicy) {
-  TestServer test_server(TestServer::TYPE_HTTP, FilePath());
+  LocalHttpServer test_server;
   ASSERT_TRUE(test_server.Start());
 
   // Set up a cookie.
   {
     TestDelegate d;
     URLRequest req(test_server.GetURL("set-cookie?CookieToNotUpdate=2"),  &d);
     req.set_context(default_context_);
     req.Start();
     MessageLoop::current()->Run();
 
@@ skipping 29 matching lines @@
                 == std::string::npos);
     EXPECT_TRUE(d.data_received().find("CookieToNotUpdate=2")
                 != std::string::npos);
 
     EXPECT_EQ(0, d.blocked_get_cookies_count());
     EXPECT_EQ(0, d.blocked_set_cookie_count());
   }
 }
 
 TEST_F(URLRequestTest, DoNotSaveEmptyCookies) {
-  TestServer test_server(TestServer::TYPE_HTTP, FilePath());
+  LocalHttpServer test_server;
   ASSERT_TRUE(test_server.Start());
 
   // Set up an empty cookie.
   {
     TestDelegate d;
     URLRequest req(test_server.GetURL("set-cookie"), &d);
     req.set_context(default_context_);
     req.Start();
     MessageLoop::current()->Run();
 
     EXPECT_EQ(0, d.blocked_get_cookies_count());
     EXPECT_EQ(0, d.blocked_set_cookie_count());
     EXPECT_EQ(0, d.set_cookie_count());
   }
 }
 
 TEST_F(URLRequestTest, DoNotSendCookies_ViaPolicy_Async) {
-  TestServer test_server(TestServer::TYPE_HTTP, FilePath());
+  LocalHttpServer test_server;
   ASSERT_TRUE(test_server.Start());
 
   // Set up a cookie.
   {
     TestDelegate d;
     URLRequest req(test_server.GetURL("set-cookie?CookieToNotSend=1"), &d);
     req.set_context(default_context_);
     req.Start();
     MessageLoop::current()->Run();
 
@@ skipping 27 matching lines @@
 
     EXPECT_TRUE(d.data_received().find("Cookie: CookieToNotSend=1")
                 == std::string::npos);
 
     EXPECT_EQ(1, d.blocked_get_cookies_count());
     EXPECT_EQ(0, d.blocked_set_cookie_count());
   }
 }
 
 TEST_F(URLRequestTest, DoNotSaveCookies_ViaPolicy_Async) {
-  TestServer test_server(TestServer::TYPE_HTTP, FilePath());
+  LocalHttpServer test_server;
   ASSERT_TRUE(test_server.Start());
 
   // Set up a cookie.
   {
     TestDelegate d;
     URLRequest req(test_server.GetURL("set-cookie?CookieToNotUpdate=2"), &d);
     req.set_context(default_context_);
     req.Start();
     MessageLoop::current()->Run();
 
@@ skipping 35 matching lines @@
 }
 
 void CheckCookiePolicyCallback(bool* was_run, const CookieList& cookies) {
   EXPECT_EQ(1U, cookies.size());
   EXPECT_FALSE(cookies[0].IsPersistent());
   *was_run = true;
   MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
 }
 
 TEST_F(URLRequestTest, CookiePolicy_ForceSession) {
-  TestServer test_server(TestServer::TYPE_HTTP, FilePath());
+  LocalHttpServer test_server;
   ASSERT_TRUE(test_server.Start());
 
   // Set up a cookie.
   {
     TestDelegate d;
     d.set_cookie_options(TestDelegate::FORCE_SESSION);
     URLRequest req(test_server.GetURL(
         "set-cookie?A=1;expires=\"Fri, 05 Feb 2010 23:42:01 GMT\""), &d);
     req.set_context(default_context_);
     req.Start();  // Triggers an asynchronous cookie policy check.
@@ skipping 657 matching lines @@
   EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, req.status().error());
 
   EXPECT_EQ(1, network_delegate.error_count());
   EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, network_delegate.last_error());
   EXPECT_EQ(1, network_delegate.completed_requests());
 }
 
 // Check that it is impossible to change the referrer in the extra headers of
 // an URLRequest.
 TEST_F(URLRequestTest, DoNotOverrideReferrer) {
-  TestServer test_server(TestServer::TYPE_HTTP, FilePath());
+  LocalHttpServer test_server;
   ASSERT_TRUE(test_server.Start());
 
   // If extra headers contain referer and the request contains a referer,
   // only the latter shall be respected.
   {
     TestDelegate d;
     TestURLRequest req(test_server.GetURL("echoheader?Referer"), &d);
     req.set_referrer("http://foo.com/");
     req.set_context(default_context_);
 
@@ skipping 38 matching lines @@
   EXPECT_EQ("", d.data_received());
   EXPECT_EQ(1, default_network_delegate_.completed_requests());
 }
 
 class URLRequestTestFTP : public URLRequestTest {
  public:
   URLRequestTestFTP() : test_server_(TestServer::TYPE_FTP, FilePath()) {
   }
 
  protected:
   TestServer test_server_;

[eroman, 2012/02/16 02:41:00]

You don't need to make the same change here (for the FTP server)?

[erikwright (departed), 2012/02/16 16:04:13]

No. Chrome Frame never handles requests besides HTTP and HTTPS. And the types of
failures we are seeing, for whatever reason, never occur over HTTPS (which is
lucky because that would lead to all kinds of certificate issues that we get
around by having certs for 127.0.0.1). In fact, we currently don't run the HTTPS
tests at all in chrome_frame_net_tests (probably why they aren't failing)
because they require manually installing the test CA in IE.

 };
 
 // Flaky, see http://crbug.com/25045.
 TEST_F(URLRequestTestFTP, FLAKY_FTPDirectoryListing) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   {
     TestURLRequest r(test_server_.GetURL("/"), &d);
     r.set_context(default_context_);
@@ skipping 472 matching lines @@
   req.SetExtraRequestHeaders(headers);
   req.Start();
   MessageLoop::current()->Run();
   // If the net tests are being run with ChromeFrame then we need to allow for
   // the 'chromeframe' suffix which is added to the user agent before the
   // closing parentheses.
   EXPECT_TRUE(StartsWithASCII(d.data_received(), "Lynx (textmode", true));
 }
 
 }  // namespace net