GTTF: Convert most tests in content to use EmbeddedTestServer.

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/file_util.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "net/test/embedded_test_server/http_connection.h"
 #include "net/test/embedded_test_server/http_request.h"
 #include "net/test/embedded_test_server/http_response.h"
 #include "net/tools/fetch/http_listen_socket.h"
 
 namespace net {
 namespace test_server {
 
 namespace {
 
 const int kPort = 8040;
 const char kIp[] = "127.0.0.1";
 const int kRetries = 10;
 
-// Callback to handle requests with default predefined response for requests
-// matching the address |url|.
-scoped_ptr<HttpResponse> HandleDefaultRequest(const GURL& url,
-                                              const HttpResponse& response,
-                                              const HttpRequest& request) {
-  const GURL request_url = url.Resolve(request.relative_url);
-  if (url.path() != request_url.path())
-    return scoped_ptr<HttpResponse>(NULL);
-  return scoped_ptr<HttpResponse>(new HttpResponse(response));
-}
-
 // Handles |request| by serving a file from under |server_root|.
 scoped_ptr<HttpResponse> HandleFileRequest(const base::FilePath& server_root,
                                            const HttpRequest& request) {
   // This is a test-only server. Ignore I/O thread restrictions.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
 
   // Trim the first byte ('/').
   std::string request_path(request.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);
+
   std::string file_contents;
   if (!file_util::ReadFileToString(
           server_root.AppendASCII(request_path), &file_contents)) {
     return scoped_ptr<HttpResponse>(NULL);
   }
 
-  scoped_ptr<HttpResponse> http_response(new HttpResponse);
+  scoped_ptr<HttpResponseImpl> http_response(new HttpResponseImpl);
   http_response->set_code(net::test_server::SUCCESS);
   http_response->set_content(file_contents);
-  return http_response.Pass();
+  return http_response.PassAs<HttpResponse>();
 }
 
 }  // namespace
 
 HttpListenSocket::HttpListenSocket(const SocketDescriptor socket_descriptor,
                                    StreamListenSocket::Delegate* delegate)
     : TCPListenSocket(socket_descriptor, delegate) {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
@@ skipping 84 matching lines @@
   listen_socket_ = NULL;  // Release the listen socket.
   STLDeleteContainerPairSecondPointers(connections_.begin(),
                                        connections_.end());
   connections_.clear();
 }
 
 void EmbeddedTestServer::HandleRequest(HttpConnection* connection,
                                scoped_ptr<HttpRequest> request) {
   DCHECK(io_thread_->BelongsToCurrentThread());
 
+  bool request_handled = false;
+
   for (size_t i = 0; i < request_handlers_.size(); ++i) {
     scoped_ptr<HttpResponse> response =
         request_handlers_[i].Run(*request.get());
     if (response.get()) {
       connection->SendResponse(response.Pass());
-      return;
+      request_handled = true;
+      break;
     }
   }
 
-  LOG(WARNING) << "Request not handled. Returning 404: "
-               << request->relative_url;
-  scoped_ptr<HttpResponse> not_found_response(new HttpResponse());
-  not_found_response->set_code(NOT_FOUND);
-  connection->SendResponse(not_found_response.Pass());
+  if (!request_handled) {
+    LOG(WARNING) << "Request not handled. Returning 404: "
+                 << request->relative_url;
+    scoped_ptr<HttpResponseImpl> not_found_response(new HttpResponseImpl());
+    not_found_response->set_code(NOT_FOUND);
+    connection->SendResponse(not_found_response.PassAs<HttpResponse>());
+  }
 
   // Drop the connection, since we do not support multiple requests per
   // connection.
   connections_.erase(connection->socket_.get());
   delete connection;
 }
 
 GURL EmbeddedTestServer::GetURL(const std::string& relative_url) const {
   DCHECK(StartsWithASCII(relative_url, "/", true /* case_sensitive */))
       << relative_url;
@@ skipping 53 matching lines @@
   std::map<StreamListenSocket*, HttpConnection*>::iterator it =
       connections_.find(socket);
   if (it == connections_.end()) {
     return NULL;
   }
   return it->second;
 }
 
 }  // namespace test_server
 }  // namespace net