Yet another scrape atttempt

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 242 matching lines @@
   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 FilePath& cert_path,
+             const std::wstring& file_root_url) {
     std::string blank;
     return Start(protocol, host_name, port, document_root, cert_path,
-                 blank, blank);
+                 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))
+        host_name, port, document_root, cert_path, file_root_url))
       return false;
 
     std::string scheme;
     if (protocol == net::TestServerLauncher::ProtoFTP)
       scheme = "ftp";
     else
       scheme = "http";
     if (!cert_path.empty())
       scheme.push_back('s');
 
@@ skipping 44 matching lines @@
  protected:
   explicit HTTPTestServer() : loop_(NULL) {
   }
 
  public:
   // Creates and returns a new HTTPTestServer. If |loop| is non-null, requests
   // are serviced on it, otherwise a new thread and message loop are created.
   static scoped_refptr<HTTPTestServer> CreateServer(
       const std::wstring& document_root,
       MessageLoop* loop) {
+    return CreateServerWithFileRootURL(document_root, std::wstring(), loop);
+  }
+
+  static scoped_refptr<HTTPTestServer> CreateServerWithFileRootURL(
+      const std::wstring& document_root,
+      const std::wstring& file_root_url,
+      MessageLoop* loop) {
     scoped_refptr<HTTPTestServer> test_server = new HTTPTestServer();
     test_server->loop_ = loop;
     FilePath no_cert;
     FilePath docroot = FilePath::FromWStringHack(document_root);
     if (!test_server->Start(net::TestServerLauncher::ProtoHTTP,
                             kDefaultHostName, kHTTPDefaultPort,
-                            docroot, no_cert)) {
+                            docroot, no_cert, file_root_url)) {
       return NULL;
     }
     return test_server;
   }
 
   // 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
@@ skipping 73 matching lines @@
   // TODO(dkegel): HTTPSTestServer should not require an instance to specify
   // stock test certificates
   static scoped_refptr<HTTPSTestServer> CreateGoodServer(
       const std::wstring& document_root) {
     scoped_refptr<HTTPSTestServer> test_server = new HTTPSTestServer();
     FilePath docroot = FilePath::FromWStringHack(document_root);
     FilePath certpath = test_server->launcher_.GetOKCertPath();
     if (!test_server->Start(net::TestServerLauncher::ProtoHTTP,
         net::TestServerLauncher::kHostName,
         net::TestServerLauncher::kOKHTTPSPort,
-        docroot, certpath)) {
+        docroot, certpath, std::wstring())) {
       return NULL;
     }
     return test_server;
   }
 
   // Create a server with an up to date certificate for the wrong hostname
   // for this host
   static scoped_refptr<HTTPSTestServer> CreateMismatchedServer(
       const std::wstring& document_root) {
     scoped_refptr<HTTPSTestServer> test_server = new HTTPSTestServer();
     FilePath docroot = FilePath::FromWStringHack(document_root);
     FilePath certpath = test_server->launcher_.GetOKCertPath();
     if (!test_server->Start(net::TestServerLauncher::ProtoHTTP,
         net::TestServerLauncher::kMismatchedHostName,
         net::TestServerLauncher::kOKHTTPSPort,
-        docroot, certpath)) {
+        docroot, certpath, std::wstring())) {
       return NULL;
     }
     return test_server;
   }
 
   // Create a server with an expired certificate
   static scoped_refptr<HTTPSTestServer> CreateExpiredServer(
       const std::wstring& document_root) {
     HTTPSTestServer* test_server = new HTTPSTestServer();
     FilePath docroot = FilePath::FromWStringHack(document_root);
     FilePath certpath = test_server->launcher_.GetExpiredCertPath();
     if (!test_server->Start(net::TestServerLauncher::ProtoHTTP,
         net::TestServerLauncher::kHostName,
         net::TestServerLauncher::kBadHTTPSPort,
-        docroot, certpath)) {
+        docroot, certpath, std::wstring())) {
       return NULL;
     }
     return test_server;
   }
 
   // Create a server with an arbitrary certificate
   static scoped_refptr<HTTPSTestServer> CreateServer(
       const std::string& host_name, int port,
       const std::wstring& document_root,
       const std::wstring& cert_path) {
     scoped_refptr<HTTPSTestServer> test_server = new HTTPSTestServer();
     FilePath docroot = FilePath::FromWStringHack(document_root);
     FilePath certpath = FilePath::FromWStringHack(cert_path);
     if (!test_server->Start(net::TestServerLauncher::ProtoHTTP,
-        host_name, port, docroot, certpath)) {
+        host_name, port, docroot, certpath, std::wstring())) {
       return NULL;
     }
     return test_server;
   }
 
   virtual ~HTTPSTestServer() {
   }
 
  protected:
   std::wstring cert_path_;
@@ skipping 12 matching lines @@
   }
 
   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,
+        kDefaultHostName, kFTPDefaultPort, docroot, no_cert, std::wstring(),
         url_user, url_password)) {
       return NULL;
     }
     return test_server;
   }
 
   virtual bool MakeGETRequest(const std::string& page_name) {
     const GURL& url = TestServerPage(base_address_, 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_