Speed up net_unittests by re-using one FTP test server instance.

net/url_request/url_request_unittest.h

 // 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.
 
 #ifndef NET_URL_REQUEST_URL_REQUEST_UNITTEST_H_
 #define NET_URL_REQUEST_URL_REQUEST_UNITTEST_H_
 
 #include <stdlib.h>
 
 #include <sstream>
@@ skipping 245 matching lines @@
   bool Stop() {
     return launcher_.Stop();
   }
 
   GURL TestServerPage(const std::string& base_address,
       const std::string& path) {
     return GURL(base_address + path);
   }
 
   GURL TestServerPage(const std::string& path) {
-    return GURL(base_address_ + path);
+    return GURL(scheme_ + "://" + host_name_ + ":" + port_str_ + "/" + path);

[wtc, 2009/08/31 20:38:44]

Is there a GURL method that combines these components into
a URL?

If host_name_ may be an IP address literal, we should be
careful about IPv6 address literals, which need to be put
inside square brackets [].  This also applies to the next
constructor.

   }
 
+  GURL TestServerPage(const std::string& path,
+                      const std::string& user, const std::string& password) {

[wtc, 2009/08/31 20:38:44]

This is the second form in the Style Guide:
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Function_Decla...

We're supposed to list one parameter on each line.

+    if (password.empty())
+      return GURL(scheme_ + "://" + user + "@" +
+                  host_name_ + ":" + port_str_ + "/" + path);
+    else

[wtc, 2009/08/31 20:38:44]

Nit: don't use else after a return statement.

+      return GURL(scheme_ + "://" + user + ":" + password +
+                  "@" + host_name_ + ":" + port_str_ + "/" + path);
+  }
+
+  // Deprecated in favor of TestServerPage.
+  // TODO(phajdan.jr): Remove TestServerPageW.
   GURL TestServerPageW(const std::wstring& path) {
-    return GURL(base_address_ + WideToUTF8(path));
+    return TestServerPage(WideToUTF8(path));
   }
 
   virtual bool MakeGETRequest(const std::string& page_name) = 0;
 
   std::wstring GetDataDirectory() {
     return launcher_.GetDocumentRootPath().ToWStringHack();
   }
 
  protected:
   bool Start(net::TestServerLauncher::Protocol protocol,
              const std::string& host_name, int port,
              const FilePath& document_root,
              const FilePath& cert_path,
              const std::wstring& file_root_url) {
-    std::string blank;
-    return Start(protocol, host_name, port, document_root, cert_path,
-                 file_root_url, blank, blank);
-  }
-
-  bool Start(net::TestServerLauncher::Protocol protocol,
-             const std::string& host_name, int port,
-             const FilePath& document_root,
-             const FilePath& cert_path,
-             const std::wstring& file_root_url,
-             const std::string& url_user,
-             const std::string& url_password) {
     if (!launcher_.Start(protocol,
         host_name, port, document_root, cert_path, file_root_url))
       return false;
 
-    std::string scheme;
     if (protocol == net::TestServerLauncher::ProtoFTP)
-      scheme = "ftp";
+      scheme_ = "ftp";
     else
-      scheme = "http";
+      scheme_ = "http";
     if (!cert_path.empty())
-      scheme.push_back('s');
+      scheme_.push_back('s');
 
-    std::string 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 + "/";
-    }
+    host_name_ = host_name;
+    port_str_ = IntToString(port);
     return true;
   }
 
   // Used by MakeGETRequest to implement sync load behavior.
   class SyncTestDelegate : public TestDelegate {
    public:
     SyncTestDelegate() : event_(false, false), success_(false) {
     }
     virtual void OnResponseCompleted(URLRequest* request) {
       MessageLoop::current()->DeleteSoon(FROM_HERE, request);
       success_ = request->status().is_success();
       event_.Signal();
     }
     bool Wait(int64 secs) {
       TimeDelta td = TimeDelta::FromSeconds(secs);
       if (event_.TimedWait(td))
         return true;
       return false;
     }
     bool did_succeed() const { return success_; }
    private:
     base::WaitableEvent event_;
     bool success_;
     DISALLOW_COPY_AND_ASSIGN(SyncTestDelegate);
   };
 
   net::TestServerLauncher launcher_;
-  std::string base_address_;
+  std::string scheme_;
+  std::string host_name_;
+  std::string port_str_;
 };
 
 
 // HTTP
 class HTTPTestServer : public BaseTestServer {
  protected:
   explicit HTTPTestServer() : loop_(NULL) {
   }
 
   explicit HTTPTestServer(int connection_attempts, int connection_timeout)
@@ skipping 54 matching lines @@
       return NULL;
     return test_server;
   }
 
   static bool StartTestServer(HTTPTestServer* server,
                               const FilePath& document_root,
                               const FilePath& cert_path,
                               const std::wstring& file_root_url) {
     return server->Start(net::TestServerLauncher::ProtoHTTP, kDefaultHostName,
                          kHTTPDefaultPort, document_root, cert_path,
-                         file_root_url, "", "");
+                         file_root_url);
   }
 
   // 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;
@@ skipping 137 matching lines @@
 };
 
 
 class FTPTestServer : public BaseTestServer {
  public:
   FTPTestServer() {
   }
 
   static scoped_refptr<FTPTestServer> CreateServer(
       const std::wstring& document_root) {
-    std::string blank;
-    return CreateServer(document_root, blank, blank);
-  }
-
-  static scoped_refptr<FTPTestServer> CreateServer(
-      const std::wstring& document_root,
-      const std::string& url_user,
-      const std::string& url_password) {
     scoped_refptr<FTPTestServer> test_server = new FTPTestServer();
     FilePath docroot = FilePath::FromWStringHack(document_root);
     FilePath no_cert;
     if (!test_server->Start(net::TestServerLauncher::ProtoFTP,
-        kDefaultHostName, kFTPDefaultPort, docroot, no_cert, std::wstring(),
-        url_user, url_password)) {
+        kDefaultHostName, kFTPDefaultPort, docroot, no_cert, std::wstring())) {
       return NULL;
     }
     return test_server;
   }
 
   virtual bool MakeGETRequest(const std::string& page_name) {
-    const GURL& url = TestServerPage(base_address_, 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;
   }
 };
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_UNITTEST_H_