Introduce Http{Request,Response} mojom structs.

mojo/services/network/http_connection_impl.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 "mojo/services/network/http_connection_impl.h"
 
 #include <limits>
 
 #include "base/bind_helpers.h"
 #include "base/callback.h"
@@ skipping 64 matching lines @@
 
   ScopedDataPipeConsumerHandle consumer_;
   common::HandleWatcher watcher_;
   CompletionCallback completion_callback_;
   scoped_ptr<std::string> buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(SimpleDataPipeReader);
 };
 
 template <>
-struct TypeConverter<URLRequestPtr, net::HttpServerRequestInfo> {
-  static URLRequestPtr Convert(const net::HttpServerRequestInfo& obj) {
-    URLRequestPtr request(URLRequest::New());
+struct TypeConverter<HttpRequestPtr, net::HttpServerRequestInfo> {
+  static HttpRequestPtr Convert(const net::HttpServerRequestInfo& obj) {
+    HttpRequestPtr request(HttpRequest::New());
+    request->method = obj.method;
     request->url = obj.path;
-    request->method = obj.method;
     request->headers.resize(obj.headers.size());
     size_t index = 0;
     for (const auto& item : obj.headers) {
       HTTPHeaderPtr header(HTTPHeader::New());
       header->name = item.first;
       header->value = item.second;
       request->headers[index++] = header.Pass();
     }
     if (!obj.data.empty()) {
       uint32_t num_bytes = static_cast<uint32_t>(obj.data.size());
       MojoCreateDataPipeOptions options;
       options.struct_size = sizeof(MojoCreateDataPipeOptions);
       options.flags = MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE;
       options.element_num_bytes = 1;
       options.capacity_num_bytes = num_bytes;
       DataPipe data_pipe(options);
-      request->body.push_back(data_pipe.consumer_handle.Pass());
+      request->body = data_pipe.consumer_handle.Pass();
       MojoResult result =
           WriteDataRaw(data_pipe.producer_handle.get(), obj.data.data(),
                        &num_bytes, MOJO_WRITE_DATA_FLAG_ALL_OR_NONE);
       DCHECK_EQ(MOJO_RESULT_OK, result);
     }
     return request.Pass();
   }
 };
 
 HttpConnectionImpl::HttpConnectionImpl(int connection_id,
@@ skipping 14 matching lines @@
   for (const auto& reader : response_body_readers_)
     delete reader;
 }
 
 void HttpConnectionImpl::OnReceivedHttpRequest(
     const net::HttpServerRequestInfo& info) {
   if (!delegate_)
     return;
 
   delegate_->OnReceivedRequest(
-      URLRequest::From(info), [this](URLResponsePtr response) {
+      HttpRequest::From(info), [this](HttpResponsePtr response) {
         if (response->body.is_valid()) {
           SimpleDataPipeReader* reader = new SimpleDataPipeReader;
           response_body_readers_.insert(reader);
           reader->Start(
               response->body.Pass(),
               base::Bind(&HttpConnectionImpl::OnFinishedReadingResponseBody,
                          base::Unretained(this), base::Passed(&response)));
         } else {
           OnFinishedReadingResponseBody(response.Pass(), nullptr, nullptr);
         }
@@ skipping 39 matching lines @@
     binding_.Close();
     delegate_.reset();
 
     // Don't close the connection until all pending responses are sent.
     if (response_body_readers_.empty())
       owner_->server()->Close(connection_id_);
   }
 }
 
 void HttpConnectionImpl::OnFinishedReadingResponseBody(
-    URLResponsePtr response,
+    HttpResponsePtr response,
     SimpleDataPipeReader* reader,
     scoped_ptr<std::string> body) {
   if (reader) {
     delete reader;
     response_body_readers_.erase(reader);
   }
 
   net::HttpServerResponseInfo info(
       static_cast<net::HttpStatusCode>(response->status_code));
 
@@ skipping 22 matching lines @@
   if (body)
     info.SetBody(*body, content_type);
 
   owner_->server()->SendResponse(connection_id_, info);
 
   if (response_body_readers_.empty() && encountered_connection_error_)
     owner_->server()->Close(connection_id_);
 }
 
 }  // namespace mojo