Revert 7508.7509 and 7510

Review URL: http://codereview.chromium.org/17030

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@7514 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 254 insertions, 631 deletions

diff --git a/net/proxy/proxy_script_fetcher_unittest.cc b/net/proxy/proxy_script_fetcher_unittest.cc
index 2139b6c..8507a86 100644
--- a/net/proxy/proxy_script_fetcher_unittest.cc
+++ b/net/proxy/proxy_script_fetcher_unittest.cc
@@ -181,25 +181,23 @@ TEST_F(ProxyScriptFetcherTest, FileUrl) {
 // Note that all mime types are allowed for PAC file, to be consistent
 // with other browsers.
 TEST_F(ProxyScriptFetcherTest, HttpMimeType) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(kDocRoot);
-  ASSERT_TRUE(NULL != server.get());
+  TestServer server(kDocRoot);
   SynchFetcher pac_fetcher;
 
   { // Fetch a PAC with mime type "text/plain"
-    GURL url = server->TestServerPage("files/pac.txt");
+    GURL url = server.TestServerPage("files/pac.txt");
     FetchResult result = pac_fetcher.Fetch(url);
     EXPECT_EQ(net::OK, result.code);
     EXPECT_EQ("-pac.txt-\n", result.bytes);
   }
   { // Fetch a PAC with mime type "text/html"
-    GURL url = server->TestServerPage("files/pac.html");
+    GURL url = server.TestServerPage("files/pac.html");
     FetchResult result = pac_fetcher.Fetch(url);
     EXPECT_EQ(net::OK, result.code);
     EXPECT_EQ("-pac.html-\n", result.bytes);
   }
   { // Fetch a PAC with mime type "application/x-ns-proxy-autoconfig"
-    GURL url = server->TestServerPage("files/pac.nsproxy");
+    GURL url = server.TestServerPage("files/pac.nsproxy");
     FetchResult result = pac_fetcher.Fetch(url);
     EXPECT_EQ(net::OK, result.code);
     EXPECT_EQ("-pac.nsproxy-\n", result.bytes);
@@ -207,19 +205,17 @@ TEST_F(ProxyScriptFetcherTest, HttpMimeType) {
 }
 
 TEST_F(ProxyScriptFetcherTest, HttpStatusCode) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(kDocRoot);
-  ASSERT_TRUE(NULL != server.get());
+  TestServer server(kDocRoot);
   SynchFetcher pac_fetcher;
 
   { // Fetch a PAC which gives a 500 -- FAIL
-    GURL url = server->TestServerPage("files/500.pac");
+    GURL url = server.TestServerPage("files/500.pac");
     FetchResult result = pac_fetcher.Fetch(url);
     EXPECT_EQ(net::ERR_PAC_STATUS_NOT_OK, result.code);
     EXPECT_TRUE(result.bytes.empty());
   }
   { // Fetch a PAC which gives a 404 -- FAIL
-    GURL url = server->TestServerPage("files/404.pac");
+    GURL url = server.TestServerPage("files/404.pac");
     FetchResult result = pac_fetcher.Fetch(url);
     EXPECT_EQ(net::ERR_PAC_STATUS_NOT_OK, result.code);
     EXPECT_TRUE(result.bytes.empty());
@@ -227,23 +223,19 @@ TEST_F(ProxyScriptFetcherTest, HttpStatusCode) {
 }
 
 TEST_F(ProxyScriptFetcherTest, ContentDisposition) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(kDocRoot);
-  ASSERT_TRUE(NULL != server.get());
+  TestServer server(kDocRoot);
   SynchFetcher pac_fetcher;
 
   // Fetch PAC scripts via HTTP with a Content-Disposition header -- should
   // have no effect.
-  GURL url = server->TestServerPage("files/downloadable.pac");
+  GURL url = server.TestServerPage("files/downloadable.pac");
   FetchResult result = pac_fetcher.Fetch(url);
   EXPECT_EQ(net::OK, result.code);
   EXPECT_EQ("-downloadable.pac-\n", result.bytes);
 }
 
 TEST_F(ProxyScriptFetcherTest, TooLarge) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(kDocRoot);
-  ASSERT_TRUE(NULL != server.get());
+  TestServer server(kDocRoot);
   SynchFetcher pac_fetcher;
 
   // Set the maximum response size to 50 bytes.
@@ -251,7 +243,7 @@ TEST_F(ProxyScriptFetcherTest, TooLarge) {
 
   // These two URLs are the same file, but are http:// vs file://
   GURL urls[] = {
-    server->TestServerPage("files/large-pac.nsproxy"),
+    server.TestServerPage("files/large-pac.nsproxy"),
     GetTestFileUrl("large-pac.nsproxy")
   };
 
@@ -268,7 +260,7 @@ TEST_F(ProxyScriptFetcherTest, TooLarge) {
   net::ProxyScriptFetcher::SetSizeConstraintForUnittest(prev_size);
 
   { // Make sure we can still fetch regular URLs.
-    GURL url = server->TestServerPage("files/pac.nsproxy");
+    GURL url = server.TestServerPage("files/pac.nsproxy");
     FetchResult result = pac_fetcher.Fetch(url);
     EXPECT_EQ(net::OK, result.code);
     EXPECT_EQ("-pac.nsproxy-\n", result.bytes);
@@ -276,9 +268,7 @@ TEST_F(ProxyScriptFetcherTest, TooLarge) {
 }
 
 TEST_F(ProxyScriptFetcherTest, Hang) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(kDocRoot);
-  ASSERT_TRUE(NULL != server.get());
+  TestServer server(kDocRoot);
   SynchFetcher pac_fetcher;
 
   // Set the timeout period to 0.5 seconds.
@@ -287,7 +277,7 @@ TEST_F(ProxyScriptFetcherTest, Hang) {
 
   // Try fetching a URL which takes 1.2 seconds. We should abort the request
   // after 500 ms, and fail with a timeout error.
-  { GURL url = server->TestServerPage("slow/proxy.pac?1.2");
+  { GURL url = server.TestServerPage("slow/proxy.pac?1.2");
     FetchResult result = pac_fetcher.Fetch(url);
     EXPECT_EQ(net::ERR_TIMED_OUT, result.code);
     EXPECT_TRUE(result.bytes.empty());
@@ -297,7 +287,7 @@ TEST_F(ProxyScriptFetcherTest, Hang) {
   net::ProxyScriptFetcher::SetTimeoutConstraintForUnittest(prev_timeout);
 
   { // Make sure we can still fetch regular URLs.
-    GURL url = server->TestServerPage("files/pac.nsproxy");
+    GURL url = server.TestServerPage("files/pac.nsproxy");
     FetchResult result = pac_fetcher.Fetch(url);
     EXPECT_EQ(net::OK, result.code);
     EXPECT_EQ("-pac.nsproxy-\n", result.bytes);
diff --git a/net/url_request/url_request_unittest.cc b/net/url_request/url_request_unittest.cc
index 4fe23f6..be26da9 100644
--- a/net/url_request/url_request_unittest.cc
+++ b/net/url_request/url_request_unittest.cc
@@ -83,12 +83,11 @@ class URLRequestTest : public PlatformTest {
 };
 
 TEST_F(URLRequestTest, GetTest_NoCache) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(L"");
-  ASSERT_TRUE(NULL != server.get());
+  TestServer server(L"");
+  ASSERT_TRUE(server.init_successful());
   TestDelegate d;
   {
-    TestURLRequest r(server->TestServerPage(""), &d);
+    TestURLRequest r(server.TestServerPage(""), &d);
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
@@ -105,12 +104,11 @@ TEST_F(URLRequestTest, GetTest_NoCache) {
 }
 
 TEST_F(URLRequestTest, GetTest) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(L"");
-  ASSERT_TRUE(NULL != server.get());
+  TestServer server(L"");
+  ASSERT_TRUE(server.init_successful());
   TestDelegate d;
   {
-    TestURLRequest r(server->TestServerPage(""), &d);
+    TestURLRequest r(server.TestServerPage(""), &d);
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
@@ -129,7 +127,7 @@ TEST_F(URLRequestTest, GetTest) {
 class HTTPSRequestTest : public testing::Test {
  protected:
    HTTPSRequestTest() : util_() {};
-
+ 
    SSLTestUtil util_;
 };
 
@@ -145,15 +143,14 @@ TEST_F(HTTPSRequestTest, MAYBE_HTTPSGetTest) {
   // a working document root to server the pages / and /hello.html,
   // so this test doesn't really need to specify a document root.
   // But if it did, a good one would be net/data/ssl.
-  scoped_refptr<HTTPSTestServer> server =
-      HTTPSTestServer::CreateServer(util_.kHostName, util_.kOKHTTPSPort,
-      L"net/data/ssl", util_.GetOKCertPath().ToWStringHack());
-  ASSERT_TRUE(NULL != server.get());
+  HTTPSTestServer https_server(util_.kHostName, util_.kOKHTTPSPort,
+                               L"net/data/ssl",
+                               util_.GetOKCertPath().ToWStringHack());
 
   EXPECT_TRUE(util_.CheckCATrusted());
   TestDelegate d;
   {
-    TestURLRequest r(server->TestServerPage(""), &d);
+    TestURLRequest r(https_server.TestServerPage(""), &d);
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
@@ -193,16 +190,11 @@ TEST_F(URLRequestTest, CancelTest) {
 }
 
 TEST_F(URLRequestTest, CancelTest2) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(L"");
-  ASSERT_TRUE(NULL != server.get());
-
-  // error C2446: '!=' : no conversion from 'HTTPTestServer *const '
-  // to 'const int'
-
+  TestServer server(L"");
+  ASSERT_TRUE(server.init_successful());
   TestDelegate d;
   {
-    TestURLRequest r(server->TestServerPage(""), &d);
+    TestURLRequest r(server.TestServerPage(""), &d);
 
     d.set_cancel_in_response_started(true);
 
@@ -222,12 +214,11 @@ TEST_F(URLRequestTest, CancelTest2) {
 }
 
 TEST_F(URLRequestTest, CancelTest3) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(L"");
-  ASSERT_TRUE(NULL != server.get());
+  TestServer server(L"");
+  ASSERT_TRUE(server.init_successful());
   TestDelegate d;
   {
-    TestURLRequest r(server->TestServerPage(""), &d);
+    TestURLRequest r(server.TestServerPage(""), &d);
 
     d.set_cancel_in_received_data(true);
 
@@ -250,12 +241,11 @@ TEST_F(URLRequestTest, CancelTest3) {
 }
 
 TEST_F(URLRequestTest, CancelTest4) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(L"");
-  ASSERT_TRUE(NULL != server.get());
+  TestServer server(L"");
+  ASSERT_TRUE(server.init_successful());
   TestDelegate d;
   {
-    TestURLRequest r(server->TestServerPage(""), &d);
+    TestURLRequest r(server.TestServerPage(""), &d);
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
@@ -276,15 +266,14 @@ TEST_F(URLRequestTest, CancelTest4) {
 }
 
 TEST_F(URLRequestTest, CancelTest5) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(L"");
-  ASSERT_TRUE(NULL != server.get());
+  TestServer server(L"");
+  ASSERT_TRUE(server.init_successful());
   scoped_refptr<URLRequestContext> context = new URLRequestHttpCacheContext();
 
   // populate cache
   {
     TestDelegate d;
-    URLRequest r(server->TestServerPage("cachetime"), &d);
+    URLRequest r(server.TestServerPage("cachetime"), &d);
     r.set_context(context);
     r.Start();
     MessageLoop::current()->Run();
@@ -294,7 +283,7 @@ TEST_F(URLRequestTest, CancelTest5) {
   // cancel read from cache (see bug 990242)
   {
     TestDelegate d;
-    URLRequest r(server->TestServerPage("cachetime"), &d);
+    URLRequest r(server.TestServerPage("cachetime"), &d);
     r.set_context(context);
     r.Start();
     r.Cancel();
@@ -312,9 +301,9 @@ TEST_F(URLRequestTest, CancelTest5) {
 }
 
 TEST_F(URLRequestTest, PostTest) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(L"net/data");
-  ASSERT_TRUE(NULL != server.get());
+  TestServer server(L"net/data");
+  ASSERT_TRUE(server.init_successful());
+
   const int kMsgSize = 20000;  // multiple of 10
   const int kIterations = 50;
   char *uploadBytes = new char[kMsgSize+1];
@@ -338,7 +327,7 @@ TEST_F(URLRequestTest, PostTest) {
 
   for (int i = 0; i < kIterations; ++i) {
     TestDelegate d;
-    URLRequest r(server->TestServerPage("echo"), &d);
+    URLRequest r(server.TestServerPage("echo"), &d);
     r.set_context(context);
     r.set_method("POST");
 
@@ -364,12 +353,11 @@ TEST_F(URLRequestTest, PostTest) {
 }
 
 TEST_F(URLRequestTest, PostEmptyTest) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(L"net/data");
-  ASSERT_TRUE(NULL != server.get());
+  TestServer server(L"net/data");
+  ASSERT_TRUE(server.init_successful());
   TestDelegate d;
   {
-    TestURLRequest r(server->TestServerPage("echo"), &d);
+    TestURLRequest r(server.TestServerPage("echo"), &d);
     r.set_method("POST");
 
     r.Start();
@@ -389,12 +377,11 @@ TEST_F(URLRequestTest, PostEmptyTest) {
 }
 
 TEST_F(URLRequestTest, PostFileTest) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(L"net/data");
-  ASSERT_TRUE(NULL != server.get());
+  TestServer server(L"net/data");
+  ASSERT_TRUE(server.init_successful());
   TestDelegate d;
   {
-    TestURLRequest r(server->TestServerPage("echo"), &d);
+    TestURLRequest r(server.TestServerPage("echo"), &d);
     r.set_method("POST");
 
     std::wstring dir;
@@ -422,8 +409,7 @@ TEST_F(URLRequestTest, PostFileTest) {
     int size = static_cast<int>(longsize);
     scoped_array<char> buf(new char[size]);
 
-    int size_read = static_cast<int>(file_util::ReadFile(path,
-        buf.get(), size));
+    int size_read = static_cast<int>(file_util::ReadFile(path, buf.get(), size));
     ASSERT_EQ(size, size_read);
 
     ASSERT_EQ(1, d.response_started_count()) << "request failed: " <<
@@ -520,11 +506,10 @@ TEST_F(URLRequestTest, DISABLED_DnsFailureTest) {
 }
 
 TEST_F(URLRequestTest, ResponseHeadersTest) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(L"net/data/url_request_unittest");
-  ASSERT_TRUE(NULL != server.get());
+  TestServer server(L"net/data/url_request_unittest");
+  ASSERT_TRUE(server.init_successful());
   TestDelegate d;
-  TestURLRequest req(server->TestServerPage("files/with-headers.html"), &d);
+  TestURLRequest req(server.TestServerPage("files/with-headers.html"), &d);
   req.Start();
   MessageLoop::current()->Run();
 
@@ -545,14 +530,13 @@ TEST_F(URLRequestTest, ResponseHeadersTest) {
 }
 
 TEST_F(URLRequestTest, BZip2ContentTest) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(L"net/data/filter_unittests");
-  ASSERT_TRUE(NULL != server.get());
+  TestServer server(L"net/data/filter_unittests");
+  ASSERT_TRUE(server.init_successful());
 
   // for localhost domain, we also should support bzip2 encoding
   // first, get the original file
   TestDelegate d1;
-  TestURLRequest req1(server->TestServerPage("realfiles/google.txt"), &d1);
+  TestURLRequest req1(server.TestServerPage("realfiles/google.txt"), &d1);
   req1.Start();
   MessageLoop::current()->Run();
 
@@ -560,7 +544,7 @@ TEST_F(URLRequestTest, BZip2ContentTest) {
 
   // second, get bzip2 content
   TestDelegate d2;
-  TestURLRequest req2(server->TestServerPage("realbz2files/google.txt"), &d2);
+  TestURLRequest req2(server.TestServerPage("realbz2files/google.txt"), &d2);
   req2.Start();
   MessageLoop::current()->Run();
 
@@ -571,14 +555,13 @@ TEST_F(URLRequestTest, BZip2ContentTest) {
 }
 
 TEST_F(URLRequestTest, BZip2ContentTest_IncrementalHeader) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(L"net/data/filter_unittests");
-  ASSERT_TRUE(NULL != server.get());
+  TestServer server(L"net/data/filter_unittests");
+  ASSERT_TRUE(server.init_successful());
 
   // for localhost domain, we also should support bzip2 encoding
   // first, get the original file
   TestDelegate d1;
-  TestURLRequest req1(server->TestServerPage("realfiles/google.txt"), &d1);
+  TestURLRequest req1(server.TestServerPage("realfiles/google.txt"), &d1);
   req1.Start();
   MessageLoop::current()->Run();
 
@@ -587,8 +570,7 @@ TEST_F(URLRequestTest, BZip2ContentTest_IncrementalHeader) {
   // second, get bzip2 content.  ask the testserver to send the BZ2 header in
   // two chunks with a delay between them.  this tests our fix for bug 867161.
   TestDelegate d2;
-  TestURLRequest req2(server->TestServerPage(
-      "realbz2files/google.txt?incremental-header"), &d2);
+  TestURLRequest req2(server.TestServerPage("realbz2files/google.txt?incremental-header"), &d2);
   req2.Start();
   MessageLoop::current()->Run();
 
@@ -672,12 +654,10 @@ TEST_F(URLRequestTest, ResolveShortcutTest) {
 #endif  // defined(OS_WIN)
 
 TEST_F(URLRequestTest, ContentTypeNormalizationTest) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(L"net/data/url_request_unittest");
-  ASSERT_TRUE(NULL != server.get());
-
+  TestServer server(L"net/data/url_request_unittest");
+  ASSERT_TRUE(server.init_successful());
   TestDelegate d;
-  TestURLRequest req(server->TestServerPage(
+  TestURLRequest req(server.TestServerPage(
       "files/content-type-normalization.html"), &d);
   req.Start();
   MessageLoop::current()->Run();
@@ -721,12 +701,10 @@ TEST_F(URLRequestTest, FileDirCancelTest) {
 }
 
 TEST_F(URLRequestTest, RestrictRedirects) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(L"net/data/url_request_unittest");
-  ASSERT_TRUE(NULL != server.get());
-
+  TestServer server(L"net/data/url_request_unittest");
+  ASSERT_TRUE(server.init_successful());
   TestDelegate d;
-  TestURLRequest req(server->TestServerPage(
+  TestURLRequest req(server.TestServerPage(
       "files/redirect-to-file.html"), &d);
   req.Start();
   MessageLoop::current()->Run();
@@ -736,11 +714,10 @@ TEST_F(URLRequestTest, RestrictRedirects) {
 }
 
 TEST_F(URLRequestTest, NoUserPassInReferrer) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(L"net/data/url_request_unittest");
-  ASSERT_TRUE(NULL != server.get());
+  TestServer server(L"net/data/url_request_unittest");
+  ASSERT_TRUE(server.init_successful());
   TestDelegate d;
-  TestURLRequest req(server->TestServerPage(
+  TestURLRequest req(server.TestServerPage(
       "echoheader?Referer"), &d);
   req.set_referrer("http://user:pass@foo.com/");
   req.Start();
@@ -750,13 +727,12 @@ TEST_F(URLRequestTest, NoUserPassInReferrer) {
 }
 
 TEST_F(URLRequestTest, CancelRedirect) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(L"net/data/url_request_unittest");
-  ASSERT_TRUE(NULL != server.get());
+  TestServer server(L"net/data/url_request_unittest");
+  ASSERT_TRUE(server.init_successful());
   TestDelegate d;
   {
     d.set_cancel_in_received_redirect(true);
-    TestURLRequest req(server->TestServerPage(
+    TestURLRequest req(server.TestServerPage(
         "files/redirect-test.html"), &d);
     req.Start();
     MessageLoop::current()->Run();
@@ -769,9 +745,8 @@ TEST_F(URLRequestTest, CancelRedirect) {
 }
 
 TEST_F(URLRequestTest, VaryHeader) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(L"net/data/url_request_unittest");
-  ASSERT_TRUE(NULL != server.get());
+  TestServer server(L"net/data/url_request_unittest");
+  ASSERT_TRUE(server.init_successful());
 
   scoped_refptr<URLRequestContext> context = new URLRequestHttpCacheContext();
 
@@ -780,7 +755,7 @@ TEST_F(URLRequestTest, VaryHeader) {
   // populate the cache
   {
     TestDelegate d;
-    URLRequest req(server->TestServerPage("echoheader?foo"), &d);
+    URLRequest req(server.TestServerPage("echoheader?foo"), &d);
     req.set_context(context);
     req.SetExtraRequestHeaders("foo:1");
     req.Start();
@@ -796,7 +771,7 @@ TEST_F(URLRequestTest, VaryHeader) {
   // expect a cache hit
   {
     TestDelegate d;
-    URLRequest req(server->TestServerPage("echoheader?foo"), &d);
+    URLRequest req(server.TestServerPage("echoheader?foo"), &d);
     req.set_context(context);
     req.SetExtraRequestHeaders("foo:1");
     req.Start();
@@ -808,7 +783,7 @@ TEST_F(URLRequestTest, VaryHeader) {
   // expect a cache miss
   {
     TestDelegate d;
-    URLRequest req(server->TestServerPage("echoheader?foo"), &d);
+    URLRequest req(server.TestServerPage("echoheader?foo"), &d);
     req.set_context(context);
     req.SetExtraRequestHeaders("foo:2");
     req.Start();
@@ -820,9 +795,8 @@ TEST_F(URLRequestTest, VaryHeader) {
 
 TEST_F(URLRequestTest, BasicAuth) {
   scoped_refptr<URLRequestContext> context = new URLRequestHttpCacheContext();
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(L"");
-  ASSERT_TRUE(NULL != server.get());
+  TestServer server(L"");
+  ASSERT_TRUE(server.init_successful());
 
   Time response_time;
 
@@ -832,7 +806,7 @@ TEST_F(URLRequestTest, BasicAuth) {
     d.set_username(L"user");
     d.set_password(L"secret");
 
-    URLRequest r(server->TestServerPage("auth-basic"), &d);
+    URLRequest r(server.TestServerPage("auth-basic"), &d);
     r.set_context(context);
     r.Start();
 
@@ -855,7 +829,7 @@ TEST_F(URLRequestTest, BasicAuth) {
     d.set_username(L"user");
     d.set_password(L"secret");
 
-    URLRequest r(server->TestServerPage("auth-basic"), &d);
+    URLRequest r(server.TestServerPage("auth-basic"), &d);
     r.set_context(context);
     r.set_load_flags(net::LOAD_VALIDATE_CACHE);
     r.Start();
@@ -875,20 +849,16 @@ TEST_F(URLRequestTest, BasicAuth) {
 // Content-Type header.
 // http://code.google.com/p/chromium/issues/detail?id=843
 TEST_F(URLRequestTest, Post302RedirectGet) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(L"net/data/url_request_unittest");
-  ASSERT_TRUE(NULL != server.get());
+  TestServer server(L"net/data/url_request_unittest");
   TestDelegate d;
-  TestURLRequest req(server->TestServerPage("files/redirect-to-echoall"), &d);
+  TestURLRequest req(server.TestServerPage("files/redirect-to-echoall"), &d);
   req.set_method("POST");
 
   // Set headers (some of which are specific to the POST).
   // ("Content-Length: 10" is just a junk value to make sure it gets stripped).
   req.SetExtraRequestHeaders(
-    "Content-Type: multipart/form-data; "
-    "boundary=----WebKitFormBoundaryAADeAA+NAAWMAAwZ\r\n"
-    "Accept: text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,"
-    "text/plain;q=0.8,image/png,*/*;q=0.5\r\n"
+    "Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryAADeAA+NAAWMAAwZ\r\n"
+    "Accept: text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5\r\n"
     "Accept-Language: en-US,en\r\n"
     "Accept-Charset: ISO-8859-1,*,utf-8\r\n"
     "Content-Length: 10\r\n"
@@ -915,128 +885,11 @@ TEST_F(URLRequestTest, Post302RedirectGet) {
 }
 
 TEST_F(URLRequestTest, Post307RedirectPost) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(L"net/data/url_request_unittest");
-  ASSERT_TRUE(NULL != server.get());
+  TestServer server(L"net/data/url_request_unittest");
   TestDelegate d;
-  TestURLRequest req(server->TestServerPage("files/redirect307-to-echoall"),
-      &d);
+  TestURLRequest req(server.TestServerPage("files/redirect307-to-echoall"), &d);
   req.set_method("POST");
   req.Start();
   MessageLoop::current()->Run();
   EXPECT_EQ(req.method(), "POST");
 }
-
-// TODO(ibrar) It appears that these tests are hanging or not shutting down 
-// correctly.  Disable them for now.
-#if 1  // !defined(OS_WIN)
-  #define MAYBE_FTPGetTestAnonymous   DISABLED_FTPGetTestAnonymous
-  #define MAYBE_FTPCheckWrongPassword DISABLED_FTPCheckWrongPassword
-  #define MAYBE_FTPCheckWrongUser     DISABLED_FTPCheckWrongUser
-  #define MAYBE_FTPGetTest            DISABLED_FTPGetTest
-#else
-  #define MAYBE_FTPGetTestAnonymous   FTPGetTestAnonymous
-  #define MAYBE_FTPCheckWrongPassword FTPCheckWrongPassword
-  #define MAYBE_FTPCheckWrongUser     FTPCheckWrongUser
-  #define MAYBE_FTPGetTest            FTPGetTest
-#endif
-
-TEST_F(URLRequestTest, MAYBE_FTPGetTestAnonymous) {
-  scoped_refptr<FTPTestServer> server = FTPTestServer::CreateServer(L"");
-  ASSERT_TRUE(NULL != server.get());
-  std::wstring app_path;
-  PathService::Get(base::DIR_SOURCE_ROOT, &app_path);
-  app_path.append(L"\\LICENSE");
-  TestDelegate d;
-  {
-    TestURLRequest r(server->TestServerPage("/LICENSE"), &d);
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
-
-    MessageLoop::current()->Run();
-
-    int64 file_size = 0;
-    file_util::GetFileSize(app_path, &file_size);
-
-    EXPECT_TRUE(!r.is_pending());
-    EXPECT_EQ(1, d.response_started_count());
-    EXPECT_FALSE(d.received_data_before_response());
-    EXPECT_EQ(d.bytes_received(), static_cast<int>(file_size));
-  }
-}
-
-TEST_F(URLRequestTest, MAYBE_FTPGetTest) {
-  scoped_refptr<FTPTestServer> server =
-      FTPTestServer::CreateServer(L"", "chrome", "chrome");
-  ASSERT_TRUE(NULL != server.get());
-  std::wstring app_path;
-  PathService::Get(base::DIR_SOURCE_ROOT, &app_path);
-  app_path.append(L"\\LICENSE");
-  TestDelegate d;
-  {
-    TestURLRequest r(server->TestServerPage("/LICENSE"), &d);
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
-
-    MessageLoop::current()->Run();
-
-    int64 file_size = 0;
-    file_util::GetFileSize(app_path, &file_size);
-
-    EXPECT_TRUE(!r.is_pending());
-    EXPECT_EQ(1, d.response_started_count());
-    EXPECT_FALSE(d.received_data_before_response());
-    EXPECT_EQ(d.bytes_received(), static_cast<int>(file_size));
-  }
-}
-
-TEST_F(URLRequestTest, MAYBE_FTPCheckWrongPassword) {
-  scoped_refptr<FTPTestServer> server =
-      FTPTestServer::CreateServer(L"", "chrome", "wrong_password");
-  ASSERT_TRUE(NULL != server.get());
-  std::wstring app_path;
-  PathService::Get(base::DIR_SOURCE_ROOT, &app_path);
-  app_path.append(L"\\LICENSE");
-  TestDelegate d;
-  {
-    TestURLRequest r(server->TestServerPage("/LICENSE"), &d);
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
-
-    MessageLoop::current()->Run();
-
-    int64 file_size = 0;
-    file_util::GetFileSize(app_path, &file_size);
-
-    EXPECT_TRUE(!r.is_pending());
-    EXPECT_EQ(1, d.response_started_count());
-    EXPECT_FALSE(d.received_data_before_response());
-    EXPECT_EQ(d.bytes_received(), 0);
-  }
-}
-
-TEST_F(URLRequestTest, MAYBE_FTPCheckWrongUser) {
-  scoped_refptr<FTPTestServer> server =
-      FTPTestServer::CreateServer(L"", "wrong_user", "chrome");
-  ASSERT_TRUE(NULL != server.get());
-  std::wstring app_path;
-  PathService::Get(base::DIR_SOURCE_ROOT, &app_path);
-  app_path.append(L"\\LICENSE");
-  TestDelegate d;
-  {
-    TestURLRequest r(server->TestServerPage("/LICENSE"), &d);
-    r.Start();
-    EXPECT_TRUE(r.is_pending());
-
-    MessageLoop::current()->Run();
-
-    int64 file_size = 0;
-    file_util::GetFileSize(app_path, &file_size);
-
-    EXPECT_TRUE(!r.is_pending());
-    EXPECT_EQ(1, d.response_started_count());
-    EXPECT_FALSE(d.received_data_before_response());
-    EXPECT_EQ(d.bytes_received(), 0);
-  }
-}
-
diff --git a/net/url_request/url_request_unittest.h b/net/url_request/url_request_unittest.h
index 75ef7b7..a33be39 100644
--- a/net/url_request/url_request_unittest.h
+++ b/net/url_request/url_request_unittest.h
@@ -9,7 +9,6 @@
 
 #include <sstream>
 #include <string>
-#include <vector>
 
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ -28,9 +27,7 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "googleurl/src/url_util.h"
 
-const int kHTTPDefaultPort = 1337;
-const int kFTPDefaultPort = 1338;
-
+const int kDefaultPort = 1337;
 const std::string kDefaultHostName("localhost");
 
 // This URLRequestContext does not use a local cache.
@@ -193,37 +190,29 @@ class TestDelegate : public URLRequest::Delegate {
   char buf_[4096];
 };
 
-// This object bounds the lifetime of an external python-based HTTP/FTP server
+// This object bounds the lifetime of an external python-based HTTP server
 // that can provide various responses useful for testing.
-class BaseTestServer : public base::ProcessFilter,
-                       public base::RefCounted<BaseTestServer> {
- protected:
-  BaseTestServer()
-      : process_handle_(NULL) {
+class TestServer : public base::ProcessFilter {
+ public:
+  TestServer(const std::wstring& document_root)
+      : process_handle_(NULL),
+        is_shutdown_(true) {
+    Init(kDefaultHostName, kDefaultPort, document_root, std::wstring());
   }
 
- public:
-  virtual ~BaseTestServer() {
-    if (process_handle_) {
-#if defined(OS_WIN)
-      CloseHandle(process_handle_);
-#endif
-      process_handle_ = NULL;
-    }
-    // Make sure we don't leave any stray testserver processes laying around.
-    std::wstring testserver_name =
-    file_util::GetFilenameFromPath(python_runtime_);
-    base::CleanupProcesses(testserver_name, 10000, 1, this);
-    EXPECT_EQ(0, base::GetProcessCount(testserver_name, this));
+  virtual ~TestServer() {
+    Shutdown();
   }
 
   // Implementation of ProcessFilter
   virtual bool Includes(uint32 pid, uint32 parent_pid) const {
-    // Since no process handle is set, it can't be included in the filter.
+    // This function may be called after Shutdown(), in which process_handle_ is
+    // set to NULL. Since no process handle is set, it can't be included in the
+    // filter.
     if (!process_handle_)
       return false;
     // TODO(port): rationalize return value of GetProcId
-    return pid == static_cast<uint32>(base::GetProcId(process_handle_));
+    return pid == (uint32)base::GetProcId(process_handle_);
   }
 
   GURL TestServerPage(const std::string& path) {
@@ -234,46 +223,101 @@ class BaseTestServer : public base::ProcessFilter,
     return GURL(base_address_ + WideToUTF8(path));
   }
 
-  void SetPythonPaths() {
+  // A subclass may wish to send the request in a different manner
+  virtual bool MakeGETRequest(const std::string& page_name) {
+    const GURL& url = TestServerPage(page_name);
+
+    // Spin up a background thread for this request so that we have access to
+    // an IO message loop, and in cases where this thread already has an IO
+    // message loop, we also want to avoid spinning a nested message loop.
+    
+    SyncTestDelegate d;
+    {
+      base::Thread io_thread("MakeGETRequest");
+      base::Thread::Options options;
+      options.message_loop_type = MessageLoop::TYPE_IO;
+      io_thread.StartWithOptions(options);
+      io_thread.message_loop()->PostTask(FROM_HERE, NewRunnableFunction(
+          &TestServer::StartGETRequest, url, &d));
+      d.Wait();
+    }
+    return d.did_succeed();
+  }
+
+  bool init_successful() const { return init_successful_; }
+
+ protected:
+  struct ManualInit {};
+
+  // Used by subclasses that need to defer initialization until they are fully
+  // constructed.  The subclass should call Init once it is ready (usually in
+  // its constructor).
+  TestServer(ManualInit)
+      : process_handle_(NULL),
+        init_successful_(false),
+        is_shutdown_(true) {
+  }
+
+  virtual std::string scheme() { return std::string("http"); }
+
+  // This is in a separate function so that we can have assertions and so that
+  // subclasses can call this later.
+  void Init(const std::string& host_name, int port,
+            const std::wstring& document_root,
+            const std::wstring& cert_path) {
+    std::stringstream ss;
+    std::string port_str;
+    ss << (port ? port : kDefaultPort);
+    ss >> port_str;
+    base_address_ = scheme() + "://" + host_name + ":" + port_str + "/";
+
+    std::wstring testserver_path;
+    ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &testserver_path));
+    file_util::AppendToPath(&testserver_path, L"net");
+    file_util::AppendToPath(&testserver_path, L"tools");
+    file_util::AppendToPath(&testserver_path, L"testserver");
+    file_util::AppendToPath(&testserver_path, L"testserver.py");
+
+    ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &python_runtime_));
+    file_util::AppendToPath(&python_runtime_, L"third_party");
+    file_util::AppendToPath(&python_runtime_, L"python_24");
+    file_util::AppendToPath(&python_runtime_, L"python.exe");
+
+    std::wstring test_data_directory;
+    PathService::Get(base::DIR_SOURCE_ROOT, &test_data_directory);
+    std::wstring normalized_document_root = document_root;
 #if defined(OS_WIN)
-     // Set up PYTHONPATH so that Python is able to find the in-tree copy of
-    // pyftpdlib.
-    static bool set_python_path = false;
-    if (!set_python_path) {
-      FilePath pyftpdlib_path;
-      ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &pyftpdlib_path));
-      pyftpdlib_path = pyftpdlib_path.Append(L"third_party");
-      pyftpdlib_path = pyftpdlib_path.Append(L"pyftpdlib");
-
-      const wchar_t kPythonPath[] = L"PYTHONPATH";
-      wchar_t python_path_c[1024];
-      if (GetEnvironmentVariable(kPythonPath, python_path_c, 1023) > 0) {
-        // PYTHONPATH is already set, append to it.
-        std::wstring python_path(python_path_c);
-        python_path.append(L":");
-        python_path.append(pyftpdlib_path.value());
-        SetEnvironmentVariableW(kPythonPath, python_path.c_str());
-      } else {
-        SetEnvironmentVariableW(kPythonPath, pyftpdlib_path.value().c_str());
-      }
+    std::replace(normalized_document_root.begin(),
+                 normalized_document_root.end(),
+                 L'/', FilePath::kSeparators[0]);
+#endif
+    file_util::AppendToPath(&test_data_directory, normalized_document_root);
 
-      set_python_path = true;
+#if defined(OS_WIN)
+    std::wstring command_line =
+        L"\"" + python_runtime_ + L"\" " + L"\"" + testserver_path +
+        L"\" --port=" + UTF8ToWide(port_str) + L" --data-dir=\"" +
+        test_data_directory + L"\"";
+    if (!cert_path.empty()) {
+      command_line.append(L" --https=\"");
+      command_line.append(cert_path);
+      command_line.append(L"\"");
     }
+
+    ASSERT_TRUE(
+        base::LaunchApp(command_line, false, true, &process_handle_)) <<
+        "Failed to launch " << command_line;
 #elif defined(OS_POSIX)
     // Set up PYTHONPATH so that Python is able to find the in-tree copy of
-    // tlslite and pyftpdlib.
+    // tlslite.
+
     static bool set_python_path = false;
     if (!set_python_path) {
       FilePath tlslite_path;
-      FilePath pyftpdlib_path;
       ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &tlslite_path));
       tlslite_path = tlslite_path.Append("third_party");
       tlslite_path = tlslite_path.Append("tlslite");
 
-      ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &pyftpdlib_path));
-      pyftpdlib_path = pyftpdlib_path.Append("third_party");
-      pyftpdlib_path = pyftpdlib_path.Append("pyftpdlib");
-
       const char kPythonPath[] = "PYTHONPATH";
       char* python_path_c = getenv(kPythonPath);
       if (python_path_c) {
@@ -281,89 +325,81 @@ class BaseTestServer : public base::ProcessFilter,
         std::string python_path(python_path_c);
         python_path.append(":");
         python_path.append(tlslite_path.value());
-        python_path.append(":");
-        python_path.append(pyftpdlib_path.value());
         setenv(kPythonPath, python_path.c_str(), 1);
       } else {
-        std::string python_path = tlslite_path.value().c_str();
-        python_path.append(":");
-        python_path.append(pyftpdlib_path.value());
-        setenv(kPythonPath, python_path.c_str(), 1);
+        setenv(kPythonPath, tlslite_path.value().c_str(), 1);
       }
+
       set_python_path = true;
     }
+
+    std::vector<std::string> command_line;
+    command_line.push_back("python");
+    command_line.push_back(WideToUTF8(testserver_path));
+    command_line.push_back("--port=" + port_str);
+    command_line.push_back("--data-dir=" + WideToUTF8(test_data_directory));
+    if (!cert_path.empty()) 
+      command_line.push_back("--https=" + WideToUTF8(cert_path));
+
+    base::file_handle_mapping_vector no_mappings;
+    ASSERT_TRUE(
+        base::LaunchApp(command_line, no_mappings, false, &process_handle_)) <<
+        "Failed to launch " << command_line[0] << " ...";
 #endif
-  }
 
-  void SetAppPath(const std::string& host_name, int port,
-      const std::wstring& document_root, const std::string& scheme,
-      std::wstring* testserver_path, std::wstring* test_data_directory) {
-    port_str_ = IntToString(port);
-    if (url_user_.empty()) {
-      base_address_ = scheme + "://" + host_name + ":" + port_str_ + "/";
-    } else {
-      if (url_password_.empty())
-        base_address_ = scheme + "://" + url_user_ + "@" +
-            host_name + ":" + port_str_ + "/";
-      else
-        base_address_ = scheme + "://" + url_user_ + ":" + url_password_ +
-            "@" + host_name + ":" + port_str_ + "/";
+    // Verify that the webserver is actually started.
+    // Otherwise tests can fail if they run faster than Python can start.
+    int retries = 10;
+    bool success;
+    while ((success = MakeGETRequest("hello.html")) == false && retries > 0) {
+      retries--;
+      PlatformThread::Sleep(500);
     }
+    ASSERT_TRUE(success) << "Webserver not starting properly.";
 
-    ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, testserver_path));
-    file_util::AppendToPath(testserver_path, L"net");
-    file_util::AppendToPath(testserver_path, L"tools");
-    file_util::AppendToPath(testserver_path, L"testserver");
-    file_util::AppendToPath(testserver_path, L"testserver.py");
-
-    ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &python_runtime_));
-    file_util::AppendToPath(&python_runtime_, L"third_party");
-    file_util::AppendToPath(&python_runtime_, L"python_24");
-    file_util::AppendToPath(&python_runtime_, L"python.exe");
+    init_successful_ = true;
+    is_shutdown_ = false;
+  }
 
-    PathService::Get(base::DIR_SOURCE_ROOT, test_data_directory);
-    std::wstring normalized_document_root = document_root;
+  void Shutdown() {
+    if (is_shutdown_)
+      return;
 
-#if defined(OS_WIN)
-    // It is just for windows only and have no effect on other OS
-    std::replace(normalized_document_root.begin(),
-        normalized_document_root.end(),
-        L'/', FilePath::kSeparators[0]);
-#endif
-    if (!normalized_document_root.empty())
-      file_util::AppendToPath(test_data_directory, normalized_document_root);
-
-  }
+    // here we append the time to avoid problems where the kill page
+    // is being cached rather than being executed on the server
+    std::ostringstream page_name;
+    page_name << "kill?" << (unsigned int)(base::Time::Now().ToInternalValue());
+    int retry_count = 5;
+    while (retry_count > 0) {
+      bool r = MakeGETRequest(page_name.str());
+      // BUG #1048625 causes the kill GET to fail.  For now we just retry.
+      // Once the bug is fixed, we should remove the while loop and put back
+      // the following DCHECK.
+      // DCHECK(r);
+      if (r)
+        break;
+      retry_count--;
+    }
+    // Make sure we were successfull in stopping the testserver.
+    DCHECK(retry_count > 0);
 
+    if (process_handle_) {
 #if defined(OS_WIN)
-  void LaunchApp(const std::wstring& command_line) {
-    ASSERT_TRUE(base::LaunchApp(command_line, false, true, &process_handle_)) <<
-                "Failed to launch " << command_line;
-  }
-#elif defined(OS_POSIX)
-  void LaunchApp(const std::vector<std::string>& command_line) {
-    ASSERT_TRUE(base::LaunchApp(command_line, false, true, &process_handle_)) <<
-                "Failed to launch " << command_line[0] << " ...";
-  }
+      CloseHandle(process_handle_);
 #endif
+      process_handle_ = NULL;
+    }
 
-  virtual bool MakeGETRequest(const std::string& page_name) = 0;
+    // Make sure we don't leave any stray testserver processes laying around.
+    std::wstring testserver_name =
+        file_util::GetFilenameFromPath(python_runtime_);
+    base::CleanupProcesses(testserver_name, 10000, 1, this);
+    EXPECT_EQ(0, base::GetProcessCount(testserver_name, this));
 
-  // Verify that the Server is actually started.
-  // Otherwise tests can fail if they run faster than Python can start.
-  bool VerifyLaunchApp(const std::string& page_name) {
-    int retries = 10;
-    bool success;
-    while ((success = MakeGETRequest(page_name)) == false && retries > 0) {
-      retries--;
-      PlatformThread::Sleep(500);
-    }
-    if (!success)
-      return false;
-    return true;
+    is_shutdown_ = true;
   }
 
- protected:
+ private:
   // Used by MakeGETRequest to implement sync load behavior.
   class SyncTestDelegate : public TestDelegate {
    public:
@@ -381,73 +417,6 @@ class BaseTestServer : public base::ProcessFilter,
     bool success_;
     DISALLOW_COPY_AND_ASSIGN(SyncTestDelegate);
   };
-
-  std::string base_address_;
-  std::string url_user_;
-  std::string url_password_;
-  std::wstring python_runtime_;
-  base::ProcessHandle process_handle_;
-  std::string port_str_;
-};
-
-class HTTPTestServer : public BaseTestServer {
- protected:
-  HTTPTestServer() {
-  }
-
- public:
-  static HTTPTestServer* CreateServer(const std::wstring& document_root) {
-    HTTPTestServer* test_server = new HTTPTestServer();
-    if (!test_server->Init(kDefaultHostName, kHTTPDefaultPort, document_root)) {
-      delete test_server;
-      return NULL;
-    }
-    return test_server;
-  }
-
-  bool Init(const std::string& host_name, int port,
-            const std::wstring& document_root) {
-    std::wstring testserver_path;
-    std::wstring test_data_directory;
-#if defined(OS_WIN)
-    std::wstring command_line;
-#elif defined(OS_POSIX)
-    std::vector<std::string> command_line;
-#endif
-
-    // Set PYTHONPATH for tlslite and pyftpdlib
-    SetPythonPaths();
-    SetAppPath(kDefaultHostName, port, document_root, scheme(),
-        &testserver_path, &test_data_directory);
-    SetCommandLineOption(testserver_path, test_data_directory, &command_line);
-    LaunchApp(command_line);
-    if (!VerifyLaunchApp("hello.html")) {
-      LOG(ERROR) << "Webserver not starting properly";
-      return false;
-    }
-    return true;
-  }
-
-  // A subclass may wish to send the request in a different manner
-  virtual bool MakeGETRequest(const std::string& page_name) {
-    const GURL& url = TestServerPage(page_name);
-
-    // Spin up a background thread for this request so that we have access to
-    // an IO message loop, and in cases where this thread already has an IO
-    // message loop, we also want to avoid spinning a nested message loop.
-    SyncTestDelegate d;
-    {
-      base::Thread io_thread("MakeGETRequest");
-      base::Thread::Options options;
-      options.message_loop_type = MessageLoop::TYPE_IO;
-      io_thread.StartWithOptions(options);
-      io_thread.message_loop()->PostTask(FROM_HERE, NewRunnableFunction(
-          &HTTPTestServer::StartGETRequest, url, &d));
-      d.Wait();
-    }
-    return d.did_succeed();
-  }
-
   static void StartGETRequest(const GURL& url, URLRequest::Delegate* delegate) {
     URLRequest* request = new URLRequest(url, delegate);
     request->set_context(new TestURLRequestContext());
@@ -456,212 +425,23 @@ class HTTPTestServer : public BaseTestServer {
     EXPECT_TRUE(request->is_pending());
   }
 
-  virtual ~HTTPTestServer() {
-    // here we append the time to avoid problems where the kill page
-    // is being cached rather than being executed on the server
-    std::string page_name = StringPrintf("kill?%u",
-        static_cast<int>(base::Time::Now().ToInternalValue()));
-    int retry_count = 5;
-    while (retry_count > 0) {
-      bool r = MakeGETRequest(page_name);
-      // BUG #1048625 causes the kill GET to fail.  For now we just retry.
-      // Once the bug is fixed, we should remove the while loop and put back
-      // the following DCHECK.
-      // DCHECK(r);
-      if (r)
-        break;
-      retry_count--;
-    }
-    // Make sure we were successfull in stopping the testserver.
-    DCHECK(retry_count > 0);
-  }
-
-  virtual std::string scheme() { return "http"; }
-
-#if defined(OS_WIN)
-  virtual void SetCommandLineOption(const std::wstring& testserver_path,
-                            const std::wstring& test_data_directory,
-                            std::wstring* command_line ) {
-    command_line->append(L"\"" + python_runtime_ + L"\" " + L"\"" +
-    testserver_path + L"\" --port=" + UTF8ToWide(port_str_) +
-    L" --data-dir=\"" + test_data_directory + L"\"");
-  }
-#elif defined(OS_POSIX)
-  virtual void SetCommandLineOption(const std::wstring& testserver_path,
-                            const std::wstring& test_data_directory,
-                            std::vector<std::string>* command_line) {
-    command_line->push_back("python");
-    command_line->push_back(WideToUTF8(testserver_path));
-    command_line->push_back("--port=" + port_str_);
-    command_line->push_back("--data-dir=" + WideToUTF8(test_data_directory));
-  }
-#endif
-};
-
-class HTTPSTestServer : public HTTPTestServer {
- protected:
-  explicit HTTPSTestServer(const std::wstring& cert_path)
-      : cert_path_(cert_path) {
-  }
-
- public:
-  static HTTPSTestServer* CreateServer(const std::string& host_name, int port,
-                                       const std::wstring& document_root,
-                                       const std::wstring& cert_path) {
-    HTTPSTestServer* test_server = new HTTPSTestServer(cert_path);
-    if (!test_server->Init(host_name, port, document_root)) {
-      delete test_server;
-      return NULL;
-    }
-    return test_server;
-  }
-
-#if defined(OS_WIN)
-  virtual void SetCommandLineOption(const std::wstring& testserver_path,
-                            const std::wstring& test_data_directory,
-                            std::wstring* command_line ) {
-    command_line->append(L"\"" + python_runtime_ + L"\" " + L"\"" +
-    testserver_path + L"\"" + L" --port=" +
-    UTF8ToWide(port_str_) + L" --data-dir=\"" +
-    test_data_directory + L"\"");
-    if (!cert_path_.empty()) {
-      command_line->append(L" --https=\"");
-      command_line->append(cert_path_);
-      command_line->append(L"\"");
-    }
-  }
-#elif defined(OS_POSIX)
-  virtual void SetCommandLineOption(const std::wstring& testserver_path,
-                            const std::wstring& test_data_directory,
-                            std::vector<std::string>* command_line) {
-    command_line->push_back("python");
-    command_line->push_back(WideToUTF8(testserver_path));
-    command_line->push_back("--port=" + port_str_);
-    command_line->push_back("--data-dir=" + WideToUTF8(test_data_directory));
-    if (!cert_path_.empty())
-      command_line->push_back("--https=" + WideToUTF8(cert_path_));
-}
-#endif
-
-  virtual std::string scheme() { return "https"; }
-
-  virtual ~HTTPSTestServer() {
-  }
-
- protected:
-  std::wstring cert_path_;
+  std::string base_address_;
+  std::wstring python_runtime_;
+  base::ProcessHandle process_handle_;
+  bool init_successful_;
+  bool is_shutdown_;
 };
 
-
-class FTPTestServer : public BaseTestServer {
- protected:
-  FTPTestServer() {
-  }
-
+class HTTPSTestServer : public TestServer {
  public:
-  FTPTestServer(const std::string& url_user, const std::string& url_password) {
-    url_user_ = url_user;
-    url_password_ = url_password;
+   HTTPSTestServer(const std::string& host_name, int port,
+                   const std::wstring& document_root,
+                   const std::wstring& cert_path) : TestServer(ManualInit()) {
+    Init(host_name, port, document_root, cert_path);
   }
 
-  static FTPTestServer* CreateServer(const std::wstring& document_root) {
-    FTPTestServer* test_server = new FTPTestServer();
-    if (!test_server->Init(kDefaultHostName, kFTPDefaultPort, document_root)) {
-      delete test_server;
-      return NULL;
-    }
-    return test_server;
-  }
-
-  static FTPTestServer* CreateServer(const std::wstring& document_root,
-                                     const std::string& url_user,
-                                     const std::string& url_password) {
-    FTPTestServer* test_server = new FTPTestServer(url_user, url_password);
-    if (!test_server->Init(kDefaultHostName, kFTPDefaultPort, document_root)) {
-      delete test_server;
-      return NULL;
-    }
-    return test_server;
-  }
-
-  bool Init(const std::string& host_name, int port,
-            const std::wstring& document_root) {
-    std::wstring testserver_path;
-    std::wstring test_data_directory;
-
-#if defined(OS_WIN)
-    std::wstring command_line;
-#elif defined(OS_POSIX)
-    std::vector<std::string> command_line;
-#endif
-
-    // Set PYTHONPATH for tlslite and pyftpdlib
-    SetPythonPaths();
-    SetAppPath(kDefaultHostName, port, document_root, scheme(),
-        &testserver_path, &test_data_directory);
-    SetCommandLineOption(testserver_path, test_data_directory, &command_line);
-    LaunchApp(command_line);
-    if (!VerifyLaunchApp("/LICENSE")) {
-      LOG(ERROR) << "FTPServer not starting properly.";
-      return false;
-    }
-    return true;
-  }
-
-  virtual ~FTPTestServer() {
-    int retry_count = 5;
-    while (retry_count > 0) {
-      bool r = MakeGETRequest("kill");
-      // For some reason, this is failing some of the time on the bots.
-      // It appears to be a different reason than BUG #1048625 (see above), 
-      // which is a Vista + WinHTTP issue.  This failure is on XP and our FTP
-      // code curerntly uses WinInet.
-      if (r)
-        break;
-      retry_count--;
-    }
-    // Make sure we were successfull in stopping the testserver.
-    DCHECK(retry_count > 0);
-  }
-
-  virtual std::string scheme() { return "ftp"; }
-
-  virtual bool MakeGETRequest(const std::string& page_name) {
-    const GURL& url = TestServerPage(page_name);
-    TestDelegate d;
-    URLRequest request(url, &d);
-    request.set_context(new TestURLRequestContext());
-    request.set_method("GET");
-    request.Start();
-    EXPECT_TRUE(request.is_pending());
-
-    MessageLoop::current()->Run();
-    if (request.is_pending())
-      return false;
-
-    return true;
-  }
-
-#if defined(OS_WIN)
-  virtual void SetCommandLineOption(const std::wstring& testserver_path,
-                            const std::wstring& test_data_directory,
-                            std::wstring* command_line ) {
-    command_line->append(L"\"" + python_runtime_ + L"\" " + L"\"" +
-    testserver_path + L"\"" + L" -f " + L" --port=" +
-    UTF8ToWide(port_str_) + L" --data-dir=\"" +
-    test_data_directory + L"\"");
-  }
-#elif defined(OS_POSIX)
-  virtual void SetCommandLineOption(const std::wstring& testserver_path,
-                            const std::wstring& test_data_directory,
-                            std::vector<std::string>* command_line) {
-    command_line->push_back("python");
-    command_line->push_back(" -f ");
-    command_line->push_back("--data-dir=" + WideToUTF8(test_data_directory));
-    command_line->push_back("--port=" + port_str_);
-    command_line->push_back("--data-dir=" + WideToUTF8(test_data_directory));
-  }
-#endif
+  virtual std::string scheme() { return std::string("https"); }
 };
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_UNITTEST_H_
+