GTTF: convert some tests in chrome to use EmbeddedTestServer patch nr 1

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/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.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 {
 
+class CustomHttpResponse : public HttpResponse {
+ public:
+  CustomHttpResponse(const std::string& headers, const std::string& contents)
+      : headers_(headers), contents_(contents) {
+  }
+
+  virtual std::string ToResponseString() const OVERRIDE {
+    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|.
 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);
 
+  base::FilePath file_path(server_root.AppendASCII(request_path));
   std::string file_contents;
-  if (!file_util::ReadFileToString(
-          server_root.AppendASCII(request_path), &file_contents)) {
+  if (!file_util::ReadFileToString(file_path, &file_contents))
     return scoped_ptr<HttpResponse>();
+
+  base::FilePath headers_path(
+      file_path.AddExtension(FILE_PATH_LITERAL("mock-http-headers")));
+
+  if (file_util::PathExists(headers_path)) {
+    std::string headers_contents;
+    if (!file_util::ReadFileToString(headers_path, &headers_contents))
+      return scoped_ptr<HttpResponse>(NULL);
+
+    scoped_ptr<CustomHttpResponse> http_response(
+        new CustomHttpResponse(headers_contents, file_contents));
+    return http_response.PassAs<HttpResponse>();
   }
 
   scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
-  http_response->set_code(net::test_server::SUCCESS);
+  http_response->set_code(HTTP_OK);
   http_response->set_content(file_contents);
   return http_response.PassAs<HttpResponse>();
 }
 
 }  // namespace
 
 HttpListenSocket::HttpListenSocket(const SocketDescriptor socket_descriptor,
                                    StreamListenSocket::Delegate* delegate)
     : TCPListenSocket(socket_descriptor, delegate) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 100 matching lines @@
       connection->SendResponse(response.Pass());
       request_handled = true;
       break;
     }
   }
 
   if (!request_handled) {
     LOG(WARNING) << "Request not handled. Returning 404: "
                  << request->relative_url;
     scoped_ptr<BasicHttpResponse> not_found_response(new BasicHttpResponse);
-    not_found_response->set_code(NOT_FOUND);
+    not_found_response->set_code(HTTP_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;
 }
 
@@ skipping 56 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