Update monet.

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"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
-#include "mojo/common/handle_watcher.h"
+#include "mojo/message_pump/handle_watcher.h"
 #include "mojo/services/network/http_server_impl.h"
 #include "mojo/services/network/interfaces/web_socket.mojom.h"
 #include "mojo/services/network/net_adapters.h"
 #include "mojo/services/network/web_socket_read_queue.h"
 #include "mojo/services/network/web_socket_write_queue.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/server/http_server.h"
 #include "net/server/http_server_request_info.h"
@@ skipping 59 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(SimpleDataPipeReader);
 };
 
 class HttpConnectionImpl::WebSocketImpl : public WebSocket {
  public:
   // |connection| must outlive this object.
   WebSocketImpl(HttpConnectionImpl* connection,
                 InterfaceRequest<WebSocket> request,
                 ScopedDataPipeConsumerHandle send_stream,
-                WebSocketClientPtr client)
+                InterfaceHandle<WebSocketClient> client)
       : connection_(connection),
         binding_(this, request.Pass()),
-        client_(client.Pass()),
+        client_(WebSocketClientPtr::Create(client.Pass())),
         send_stream_(send_stream.Pass()),
         read_send_stream_(new WebSocketReadQueue(send_stream_.get())),
         pending_send_count_(0) {
     DCHECK(binding_.is_bound());
     DCHECK(client_);
     DCHECK(send_stream_.is_valid());
 
     binding_.set_connection_error_handler([this]() { Close(); });
     client_.set_connection_error_handler([this]() { Close(); });
 
@@ skipping 30 matching lines @@
         base::Bind(&WebSocketImpl::OnFinishedWritingReceiveStream,
                    base::Unretained(this), size));
   }
 
  private:
   // WebSocket implementation.
   void Connect(const String& url,
                Array<String> protocols,
                const String& origin,
                ScopedDataPipeConsumerHandle send_stream,
-               WebSocketClientPtr client) override {
+               InterfaceHandle<WebSocketClient> client) override {
     NOTREACHED();
   }
 
   void Send(bool fin, MessageType type, uint32_t num_bytes) override {
     if (!fin || type != MessageType::TEXT) {
       NOTIMPLEMENTED();
       Close();
     }
 
     // TODO(yzshen): It shouldn't be an issue to pass an empty message. However,
@@ skipping 84 matching lines @@
       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,
-                                       HttpServerImpl* server,
-                                       HttpConnectionDelegatePtr delegate,
-                                       HttpConnectionPtr* connection)
+HttpConnectionImpl::HttpConnectionImpl(
+    int connection_id,
+    HttpServerImpl* server,
+    HttpConnectionDelegatePtr delegate,
+    InterfaceHandle<HttpConnection>* connection)
     : connection_id_(connection_id),
       server_(server),
       delegate_(delegate.Pass()),
       binding_(this, connection) {
   DCHECK(delegate_);
   binding_.set_connection_error_handler([this]() { Close(); });
   delegate_.set_connection_error_handler([this]() { Close(); });
 }
 
 HttpConnectionImpl::~HttpConnectionImpl() {
@@ skipping 23 matching lines @@
 
 void HttpConnectionImpl::OnReceivedWebSocketRequest(
     const net::HttpServerRequestInfo& info) {
   if (IsClosing())
     return;
 
   delegate_->OnReceivedWebSocketRequest(
       HttpRequest::From(info),
       [this, info](InterfaceRequest<WebSocket> web_socket,
                    ScopedDataPipeConsumerHandle send_stream,
-                   WebSocketClientPtr web_socket_client) {
+                   InterfaceHandle<WebSocketClient> web_socket_client) {
         if (!web_socket.is_pending() || !send_stream.is_valid() ||
             !web_socket_client) {
           Close();
           return;
         }
 
         web_socket_.reset(new WebSocketImpl(this, web_socket.Pass(),
                                             send_stream.Pass(),
                                             web_socket_client.Pass()));
         server_->server()->AcceptWebSocket(connection_id_, info);
@@ skipping 100 matching lines @@
     // The close operation is initiated by this object.
     NotifyOwnerCloseIfAllDone();
   } else {
     // The close operation is initiated by |web_socket_|; start closing this
     // object.
     Close();
   }
 }
 
 }  // namespace mojo