Introduce Http{Request,Response} mojom structs.

mojo/services/network/http_server_apptest.cc

 // Copyright 2015 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 "base/macros.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
@@ skipping 50 matching lines @@
   std::string message = data.method + " " + data.url + " HTTP/1.1\r\n";
   for (const auto& item : data.headers)
     message += item.first + ": " + item.second + "\r\n";
   message += "\r\n";
   if (data.body)
     message += *data.body;
 
   return message;
 }
 
-URLResponsePtr MakeResponseStruct(const TestResponse& data) {
-  URLResponsePtr response(URLResponse::New());
+HttpResponsePtr MakeResponseStruct(const TestResponse& data) {
+  HttpResponsePtr response(HttpResponse::New());
   response->status_code = data.status_code;
   response->headers.resize(data.headers.size());
   size_t index = 0;
   for (const auto& item : data.headers) {
     HTTPHeaderPtr header(HTTPHeader::New());
     header->name = item.first;
     header->value = item.second;
     response->headers[index++] = header.Pass();
   }
 
@@ skipping 26 matching lines @@
     header_map[lower_name] = headers[i]->value;
   }
 
   for (const auto& item : expected) {
     std::string lower_name = base::StringToLowerASCII(item.first);
     EXPECT_NE(header_map.end(), header_map.find(lower_name));
     EXPECT_EQ(item.second, header_map[lower_name]);
   }
 }
 
-void CheckRequest(const TestRequest& expected, URLRequestPtr request) {
+void CheckRequest(const TestRequest& expected, HttpRequestPtr request) {
   EXPECT_EQ(expected.method, request->method);
   EXPECT_EQ(expected.url, request->url);
   CheckHeaders(expected.headers, request->headers);
   if (expected.body) {
-    EXPECT_EQ(1u, request->body.size());
+    EXPECT_TRUE(request->body.is_valid());
     std::string body;
-    common::BlockingCopyToString(request->body[0].Pass(), &body);
+    common::BlockingCopyToString(request->body.Pass(), &body);
     EXPECT_EQ(*expected.body, body);
   } else {
-    EXPECT_EQ(0u, request->body.size());
+    EXPECT_FALSE(request->body.is_valid());
   }
 }
 
 void CheckResponse(const TestResponse& expected, const std::string& response) {
   int header_end =
       net::HttpUtil::LocateEndOfHeaders(response.c_str(), response.size());
   std::string assembled_headers =
       net::HttpUtil::AssembleRawHeaders(response.c_str(), header_end);
   scoped_refptr<net::HttpResponseHeaders> parsed_headers(
       new net::HttpResponseHeaders(assembled_headers));
@@ skipping 117 matching lines @@
   scoped_refptr<net::DrainableIOBuffer> write_buffer_;
   scoped_ptr<net::TCPClientSocket> socket_;
   int connect_result_;
 
   DISALLOW_COPY_AND_ASSIGN(TestHttpClient);
 };
 
 class HttpConnectionDelegateImpl : public HttpConnectionDelegate {
  public:
   struct PendingRequest {
-    URLRequestPtr request;
+    HttpRequestPtr request;
     OnReceivedRequestCallback callback;
   };
 
   HttpConnectionDelegateImpl(HttpConnectionPtr connection,
                              InterfaceRequest<HttpConnectionDelegate> request)
       : connection_(connection.Pass()),
         binding_(this, request.Pass()),
         run_loop_(nullptr),
         wait_for_request_count_(0) {}
   ~HttpConnectionDelegateImpl() override {}
 
   // HttpConnectionDelegate implementation:
-  void OnReceivedRequest(URLRequestPtr request,
+  void OnReceivedRequest(HttpRequestPtr request,
                          const OnReceivedRequestCallback& callback) override {
     linked_ptr<PendingRequest> pending_request(new PendingRequest);
     pending_request->request = request.Pass();
     pending_request->callback = callback;
     pending_requests_.push_back(pending_request);
     if (run_loop_ && pending_requests_.size() >= wait_for_request_count_) {
       wait_for_request_count_ = 0;
       run_loop_->Quit();
     }
   }
 
   void OnReceivedWebSocketRequest(
-      URLRequestPtr request,
+      HttpRequestPtr request,
       const OnReceivedWebSocketRequestCallback& callback) override {
     NOTREACHED();
   }
 
-  void SendResponse(URLResponsePtr response) {
+  void SendResponse(HttpResponsePtr response) {
     ASSERT_FALSE(pending_requests_.empty());
     linked_ptr<PendingRequest> request = pending_requests_[0];
     pending_requests_.erase(pending_requests_.begin());
     request->callback.Run(response.Pass());
   }
 
   void WaitForRequest(size_t count) {
     DCHECK(!run_loop_);
 
     wait_for_request_count_ = count;
@@ skipping 163 matching lines @@
       make_scoped_ptr(new std::string("This is a test response..."))};
   connection.SendResponse(MakeResponseStruct(response_data));
 
   std::string response_message;
   client.ReadResponse(&response_message);
 
   CheckResponse(response_data, response_message);
 }
 
 }  // namespace mojo