Roll mojo SDK to 734c6e1652ff2f3b696e441722838f453f4f9b42

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 67 matching lines @@
   void OnHandleReady(MojoResult result) { ReadMore(); }
 
   ScopedDataPipeConsumerHandle consumer_;
   common::HandleWatcher watcher_;
   CompletionCallback completion_callback_;
   scoped_ptr<std::string> buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(SimpleDataPipeReader);
 };
 
-class HttpConnectionImpl::WebSocketImpl : public WebSocket,
-                                          public ErrorHandler {
+class HttpConnectionImpl::WebSocketImpl : public WebSocket {
  public:
   // |connection| must outlive this object.
   WebSocketImpl(HttpConnectionImpl* connection,
                 InterfaceRequest<WebSocket> request,
                 ScopedDataPipeConsumerHandle send_stream,
                 WebSocketClientPtr client)
       : connection_(connection),
         binding_(this, request.Pass()),
         client_(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_error_handler(this);
-    client_.set_error_handler(this);
+    binding_.set_connection_error_handler([this]() { Close(); });
+    client_.set_connection_error_handler([this]() { Close(); });
 
     DataPipe data_pipe;
     receive_stream_ = data_pipe.producer_handle.Pass();
     write_receive_stream_.reset(new WebSocketWriteQueue(receive_stream_.get()));
 
     client_->DidConnect("", "", data_pipe.consumer_handle.Pass());
   }
 
   ~WebSocketImpl() override {}
 
@@ skipping 48 matching lines @@
         num_bytes, base::Bind(&WebSocketImpl::OnFinishedReadingSendStream,
                               base::Unretained(this), num_bytes));
   }
 
   void FlowControl(int64_t quota) override { NOTIMPLEMENTED(); }
 
   void Close(uint16_t code, const String& reason) override {
     Close();
   }
 
-  // ErrorHandler implementation.
-  void OnConnectionError() override { Close(); }
-
   void OnFinishedReadingSendStream(uint32_t num_bytes, const char* data) {
     DCHECK_GT(pending_send_count_, 0u);
     pending_send_count_--;
 
     if (data) {
       connection_->server_->server()->SendOverWebSocket(
           connection_->connection_id_, std::string(data, num_bytes));
     }
 
     if (IsClosing())
@@ skipping 67 matching lines @@
 
 HttpConnectionImpl::HttpConnectionImpl(int connection_id,
                                        HttpServerImpl* server,
                                        HttpConnectionDelegatePtr delegate,
                                        HttpConnectionPtr* connection)
     : connection_id_(connection_id),
       server_(server),
       delegate_(delegate.Pass()),
       binding_(this, connection) {
   DCHECK(delegate_);
-  binding_.set_error_handler(this);
-  delegate_.set_error_handler(this);
+  binding_.set_connection_error_handler([this]() { Close(); });
+  delegate_.set_connection_error_handler([this]() { Close(); });
 }
 
 HttpConnectionImpl::~HttpConnectionImpl() {
   STLDeleteElements(&response_body_readers_);
 }
 
 void HttpConnectionImpl::OnReceivedHttpRequest(
     const net::HttpServerRequestInfo& info) {
   if (IsClosing())
     return;
@@ skipping 59 matching lines @@
     uint32_t size,
     const SetReceiveBufferSizeCallback& callback) {
   if (size > static_cast<uint32_t>(std::numeric_limits<int32_t>::max()))
     size = std::numeric_limits<int32_t>::max();
 
   server_->server()->SetReceiveBufferSize(connection_id_,
                                           static_cast<int32_t>(size));
   callback.Run(MakeNetworkError(net::OK));
 }
 
-void HttpConnectionImpl::OnConnectionError() {
-  // This method is called when the proxy side of |binding_| or the impl side of
-  // |delegate_| has closed the pipe. Although it is set as error handler for
-  // both |binding_| and |delegate_|, it will only be called at most once
-  // because when called it closes/resets |binding_| and |delegate_|.
-  Close();
-}
-
 void HttpConnectionImpl::OnFinishedReadingResponseBody(
     HttpResponsePtr response,
     SimpleDataPipeReader* reader,
     scoped_ptr<std::string> body) {
   if (reader) {
     delete reader;
     response_body_readers_.erase(reader);
   }
 
   net::HttpServerResponseInfo info(
@@ skipping 58 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