GTTF: Move more test server code from net/url_request/url_request_unittest.h

chrome/common/net/url_fetcher_unittest.cc

 // Copyright (c) 2006-2008 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 "base/message_loop_proxy.h"
 #include "base/thread.h"
 #include "base/waitable_event.h"
 #include "chrome/common/chrome_plugin_lib.h"
 #include "chrome/common/net/url_fetcher.h"
 #include "chrome/common/net/url_fetcher_protect.h"
 #include "chrome/common/net/url_request_context_getter.h"
 #include "net/http/http_response_headers.h"
+#include "net/url_request/url_request_unittest.h"
 #include "net/test/test_server.h"
-#include "net/url_request/url_request_unittest.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
 using base::TimeDelta;
 
 // TODO(eroman): Add a regression test for http://crbug.com/40505.
 
 namespace {
 
 const wchar_t kDocRoot[] = L"chrome/test/data";
@@ skipping 399 matching lines @@
 }
 
 void URLFetcherCancelTest::CancelRequest() {
   delete fetcher_;
   // The URLFetcher's test context will post a Quit task once it is
   // deleted. So if this test simply hangs, it means cancellation
   // did not work.
 }
 
 TEST_F(URLFetcherTest, SameThreadsTest) {
-  scoped_refptr<HTTPTestServer> server(HTTPTestServer::CreateServer(kDocRoot));
+  scoped_refptr<net::HTTPTestServer> server(
+      net::HTTPTestServer::CreateServer(kDocRoot));
   ASSERT_TRUE(NULL != server.get());
 
   // Create the fetcher on the main thread.  Since IO will happen on the main
   // thread, this will test URLFetcher's ability to do everything on one
   // thread.
   CreateFetcher(GURL(server->TestServerPage("defaultresponse")));
 
   MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherTest, DifferentThreadsTest) {
-  scoped_refptr<HTTPTestServer> server(HTTPTestServer::CreateServer(kDocRoot));
+  scoped_refptr<net::HTTPTestServer> server(
+      net::HTTPTestServer::CreateServer(kDocRoot));
   ASSERT_TRUE(NULL != server.get());
 
   // Create a separate thread that will create the URLFetcher.  The current
   // (main) thread will do the IO, and when the fetch is complete it will
   // terminate the main thread's message loop; then the other thread's
   // message loop will be shut down automatically as the thread goes out of
   // scope.
   base::Thread t("URLFetcher test thread");
   ASSERT_TRUE(t.Start());
   t.message_loop()->PostTask(FROM_HERE, new FetcherWrapperTask(this,
       GURL(server->TestServerPage("defaultresponse"))));
 
   MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherPostTest, Basic) {
-  scoped_refptr<HTTPTestServer> server(HTTPTestServer::CreateServer(kDocRoot));
+  scoped_refptr<net::HTTPTestServer> server(
+      net::HTTPTestServer::CreateServer(kDocRoot));
   ASSERT_TRUE(NULL != server.get());
   CreateFetcher(GURL(server->TestServerPage("echo")));
   MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherHeadersTest, Headers) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(L"net/data/url_request_unittest");
+  scoped_refptr<net::HTTPTestServer> server =
+      net::HTTPTestServer::CreateServer(L"net/data/url_request_unittest");
   ASSERT_TRUE(NULL != server.get());
   CreateFetcher(GURL(server->TestServerPage("files/with-headers.html")));
   MessageLoop::current()->Run();
   // The actual tests are in the URLFetcherHeadersTest fixture.
 }
 
 TEST_F(URLFetcherProtectTest, Overload) {
-  scoped_refptr<HTTPTestServer> server(HTTPTestServer::CreateServer(kDocRoot));
+  scoped_refptr<net::HTTPTestServer> server(
+      net::HTTPTestServer::CreateServer(kDocRoot));
   ASSERT_TRUE(NULL != server.get());
   GURL url = GURL(server->TestServerPage("defaultresponse"));
 
   // Registers an entry for test url. It only allows 3 requests to be sent
   // in 200 milliseconds.
   URLFetcherProtectManager* manager = URLFetcherProtectManager::GetInstance();
   URLFetcherProtectEntry* entry =
       new URLFetcherProtectEntry(200, 3, 11, 1, 2.0, 0, 256);
   manager->Register(url.host(), entry);
 
   CreateFetcher(url);
 
   MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherProtectTest, ServerUnavailable) {
-  scoped_refptr<HTTPTestServer> server(HTTPTestServer::CreateServer(kDocRoot));
+  scoped_refptr<net::HTTPTestServer> server(
+      net::HTTPTestServer::CreateServer(kDocRoot));
   ASSERT_TRUE(NULL != server.get());
   GURL url = GURL(server->TestServerPage("files/server-unavailable.html"));
 
   // Registers an entry for test url. The backoff time is calculated by:
   //     new_backoff = 2.0 * old_backoff + 0
   // and maximum backoff time is 256 milliseconds.
   // Maximum retries allowed is set to 11.
   URLFetcherProtectManager* manager = URLFetcherProtectManager::GetInstance();
   URLFetcherProtectEntry* entry =
       new URLFetcherProtectEntry(200, 3, 11, 1, 2.0, 0, 256);
   manager->Register(url.host(), entry);
 
   CreateFetcher(url);
 
   MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherProtectTestPassedThrough, ServerUnavailablePropagateResponse) {
-  scoped_refptr<HTTPTestServer> server(HTTPTestServer::CreateServer(kDocRoot));
+  scoped_refptr<net::HTTPTestServer> server(
+      net::HTTPTestServer::CreateServer(kDocRoot));
   ASSERT_TRUE(NULL != server.get());
   GURL url = GURL(server->TestServerPage("files/server-unavailable.html"));
 
   // Registers an entry for test url. The backoff time is calculated by:
   //     new_backoff = 2.0 * old_backoff + 0
   // and maximum backoff time is 256 milliseconds.
   // Maximum retries allowed is set to 11.
   URLFetcherProtectManager* manager = URLFetcherProtectManager::GetInstance();
   // Total time if *not* for not doing automatic backoff would be 150s.
   // In reality it should be "as soon as server responds".
   URLFetcherProtectEntry* entry =
       new URLFetcherProtectEntry(200, 3, 11, 100, 2.0, 0, 150000);
   manager->Register(url.host(), entry);
 
   CreateFetcher(url);
 
   MessageLoop::current()->Run();
 }
 
 
 TEST_F(URLFetcherBadHTTPSTest, BadHTTPSTest) {
-  scoped_refptr<HTTPSTestServer> server =
-      HTTPSTestServer::CreateExpiredServer(kDocRoot);
+  scoped_refptr<net::HTTPSTestServer> server =
+      net::HTTPSTestServer::CreateExpiredServer(kDocRoot);
   ASSERT_TRUE(NULL != server.get());
 
   CreateFetcher(GURL(server->TestServerPage("defaultresponse")));
 
   MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherCancelTest, ReleasesContext) {
-  scoped_refptr<HTTPTestServer> server(HTTPTestServer::CreateServer(kDocRoot));
+  scoped_refptr<net::HTTPTestServer> server(
+      net::HTTPTestServer::CreateServer(kDocRoot));
   ASSERT_TRUE(NULL != server.get());
   GURL url = GURL(server->TestServerPage("files/server-unavailable.html"));
 
   // Registers an entry for test url. The backoff time is calculated by:
   //     new_backoff = 2.0 * old_backoff + 0
   // The initial backoff is 2 seconds and maximum backoff is 4 seconds.
   // Maximum retries allowed is set to 2.
   URLFetcherProtectManager* manager = URLFetcherProtectManager::GetInstance();
   URLFetcherProtectEntry* entry =
       new URLFetcherProtectEntry(200, 3, 2, 2000, 2.0, 0, 4000);
   manager->Register(url.host(), entry);
 
   // Create a separate thread that will create the URLFetcher.  The current
   // (main) thread will do the IO, and when the fetch is complete it will
   // terminate the main thread's message loop; then the other thread's
   // message loop will be shut down automatically as the thread goes out of
   // scope.
   base::Thread t("URLFetcher test thread");
   ASSERT_TRUE(t.Start());
   t.message_loop()->PostTask(FROM_HERE, new FetcherWrapperTask(this, url));
 
   MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherCancelTest, CancelWhileDelayedStartTaskPending) {
-  scoped_refptr<HTTPTestServer> server(HTTPTestServer::CreateServer(kDocRoot));
+  scoped_refptr<net::HTTPTestServer> server(
+      net::HTTPTestServer::CreateServer(kDocRoot));
   ASSERT_TRUE(NULL != server.get());
   GURL url = GURL(server->TestServerPage("files/server-unavailable.html"));
 
   // Register an entry for test url.
   //
   // Ideally we would mock URLFetcherProtectEntry to return XXX seconds
   // in response to entry->UpdateBackoff(SEND).
   //
   // Unfortunately this function is time sensitive, so we fudge some numbers
   // to make it at least somewhat likely to have a non-zero deferred
@@ skipping 13 matching lines @@
   // time difference from now).
 
   base::Thread t("URLFetcher test thread");
   ASSERT_TRUE(t.Start());
   t.message_loop()->PostTask(FROM_HERE, new FetcherWrapperTask(this, url));
 
   MessageLoop::current()->Run();
 }
 
 }  // namespace.