Allow embedded_test_server to serve from multiple directories

net/test/embedded_test_server/embedded_test_server.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 "net/test/embedded_test_server/embedded_test_server.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 24 matching lines @@
     return headers_ + "\r\n" + contents_;
   }
 
  private:
   std::string headers_;
   std::string contents_;
 
   DISALLOW_COPY_AND_ASSIGN(CustomHttpResponse);
 };
 
-// Handles |request| by serving a file from under |server_root|.
+// Handles |request| by serving a file from under |server_roots|.
 scoped_ptr<HttpResponse> HandleFileRequest(
-    const base::FilePath& server_root,
+    const std::vector<base::FilePath>& server_roots,
     const HttpRequest& request) {
   // This is a test-only server. Ignore I/O thread restrictions.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
 
   std::string relative_url(request.relative_url);
   // A proxy request will have an absolute path. Simulate the proxy by stripping
   // the scheme, host, and port.
   GURL relative_gurl(relative_url);
   if (relative_gurl.is_valid())
     relative_url = relative_gurl.PathForRequest();
 
   // Trim the first byte ('/').
   std::string request_path = relative_url.substr(1);
 
   // Remove the query string if present.
   size_t query_pos = request_path.find('?');
   if (query_pos != std::string::npos)
     request_path = request_path.substr(0, query_pos);
 
-  base::FilePath file_path(server_root.AppendASCII(request_path));
-  std::string file_contents;
-  if (!base::ReadFileToString(file_path, &file_contents))
-    return scoped_ptr<HttpResponse>();
+  for (const auto& server_root : server_roots) {
+    base::FilePath file_path(server_root.AppendASCII(request_path));
+    std::string file_contents;
+    if (!base::ReadFileToString(file_path, &file_contents))
+      continue;
 
-  base::FilePath headers_path(
-      file_path.AddExtension(FILE_PATH_LITERAL("mock-http-headers")));
+    base::FilePath headers_path(
+        file_path.AddExtension(FILE_PATH_LITERAL("mock-http-headers")));
 
-  if (base::PathExists(headers_path)) {
-    std::string headers_contents;
-    if (!base::ReadFileToString(headers_path, &headers_contents))
-      return scoped_ptr<HttpResponse>();
+    if (base::PathExists(headers_path)) {
+      std::string headers_contents;
+      if (!base::ReadFileToString(headers_path, &headers_contents))
+        return scoped_ptr<HttpResponse>();
 
-    scoped_ptr<CustomHttpResponse> http_response(
-        new CustomHttpResponse(headers_contents, file_contents));
+      scoped_ptr<CustomHttpResponse> http_response(
+          new CustomHttpResponse(headers_contents, file_contents));
+      return http_response.Pass();
+    }
+
+    scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
+    http_response->set_code(HTTP_OK);
+    http_response->set_content(file_contents);
     return http_response.Pass();
   }
-
-  scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
-  http_response->set_code(HTTP_OK);
-  http_response->set_content(file_contents);
-  return http_response.Pass();
+  return scoped_ptr<HttpResponse>();
 }
 
 }  // namespace
 
 HttpListenSocket::HttpListenSocket(const SocketDescriptor socket_descriptor,
                                    StreamListenSocket::Delegate* delegate)
     : TCPListenSocket(socket_descriptor, delegate) {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
@@ skipping 170 matching lines @@
     const std::string& hostname,
     const std::string& relative_url) const {
   GURL local_url = GetURL(relative_url);
   GURL::Replacements replace_host;
   replace_host.SetHostStr(hostname);
   return local_url.ReplaceComponents(replace_host);
 }
 
 void EmbeddedTestServer::ServeFilesFromDirectory(
     const base::FilePath& directory) {
-  RegisterRequestHandler(base::Bind(&HandleFileRequest, directory));
+  std::vector<base::FilePath> directories;
+  directories.push_back(directory);
+  RegisterRequestHandler(base::Bind(&HandleFileRequest, directories));
+}
+
+void EmbeddedTestServer::ServeFilesFromDirectories(
+    const std::vector<base::FilePath>& directories) {
+  RegisterRequestHandler(base::Bind(&HandleFileRequest, directories));
 }
 
 void EmbeddedTestServer::RegisterRequestHandler(
     const HandleRequestCallback& callback) {
   request_handlers_.push_back(callback);
 }
 
 void EmbeddedTestServer::DidAccept(
     StreamListenSocket* server,
     scoped_ptr<StreamListenSocket> connection) {
@@ skipping 63 matching lines @@
           FROM_HERE, closure, run_loop.QuitClosure())) {
     return false;
   }
   run_loop.Run();
 
   return true;
 }
 
 }  // namespace test_server
 }  // namespace net