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 65 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());
+      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);
       CHECK_EQ(MOJO_RESULT_OK, result);
     }
     return request.Pass();
   }
 };
 
 HttpConnectionImpl::HttpConnectionImpl(int connection_id,
@@ skipping 12 matching lines @@
 HttpConnectionImpl::~HttpConnectionImpl() {
   STLDeleteElements(&response_body_readers_);
 }
 
 void HttpConnectionImpl::OnReceivedHttpRequest(
     const net::HttpServerRequestInfo& info) {
   if (EncounteredConnectionError())
     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 40 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));
 
   std::string content_type;
   for (size_t i = 0; i < response->headers.size(); ++i) {
-    const HTTPHeader& header = *(response->headers[i]);
+    const HttpHeader& header = *(response->headers[i]);
 
     if (body) {
       // net::HttpServerResponseInfo::SetBody() automatically sets
       // Content-Length and Content-Types, so skip the two here.
       //
       // TODO(yzshen): Consider adding to net::HttpServerResponseInfo a simple
       // setter for body which doesn't fiddle with headers.
       if (base::strcasecmp(header.name.data(),
                            net::HttpRequestHeaders::kContentLength) == 0) {
         continue;
       } else if (base::strcasecmp(header.name.data(),
                                   net::HttpRequestHeaders::kContentType) == 0) {
         content_type = header.value;
         continue;
       }
     }
     info.AddHeader(header.name, header.value);
   }
 
   if (body)
     info.SetBody(*body, content_type);
 
   owner_->server()->SendResponse(connection_id_, info);
 
   if (response_body_readers_.empty() && EncounteredConnectionError())
     owner_->server()->Close(connection_id_);
 }
 
 }  // namespace mojo