Roll mojo SDK to 734c6e1652ff2f3b696e441722838f453f4f9b42

mojo/services/network/network_service_impl.cc

 // Copyright 2014 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/network_service_impl.h"
 
 #include "mojo/services/network/cookie_store_impl.h"
 #include "mojo/services/network/host_resolver_impl.h"
 #include "mojo/services/network/http_server_impl.h"
 #include "mojo/services/network/net_adapters.h"
 #include "mojo/services/network/tcp_bound_socket_impl.h"
 #include "mojo/services/network/udp_socket_impl.h"
 #include "mojo/services/network/url_loader_impl.h"
 #include "mojo/services/network/web_socket_impl.h"
 #include "third_party/mojo/src/mojo/public/cpp/application/application_connection.h"
 
 namespace mojo {
 
-NetworkServiceImpl::NetworkServiceImpl(ApplicationConnection* connection,
+NetworkServiceImpl::NetworkServiceImpl(InterfaceRequest<NetworkService> request,
+                                       ApplicationConnection* connection,
                                        NetworkContext* context)
-    : context_(context),
+    : binding_(this, request.Pass()),
+      context_(context),
       origin_(GURL(connection->GetRemoteApplicationURL()).GetOrigin()) {
 }
 
 NetworkServiceImpl::~NetworkServiceImpl() {
 }
 
 void NetworkServiceImpl::CreateURLLoader(InterfaceRequest<URLLoader> loader) {
   // TODO(darin): Plumb origin_. Use for CORS.
   // The loader will delete itself when the pipe is closed, unless a request is
   // in progress. In which case, the loader will delete itself when the request
   // is finished.
   std::vector<URLLoaderInterceptorPtr> interceptors;
   url_loader_interceptor_factories_.ForAllPtrs(
       [&interceptors](URLLoaderInterceptorFactory* factory) {
         URLLoaderInterceptorPtr interceptor;
         factory->Create(GetProxy(&interceptor));
         interceptors.push_back(interceptor.Pass());
       });
   new URLLoaderImpl(context_, loader.Pass(), std::move(interceptors));
 }
 
 void NetworkServiceImpl::GetCookieStore(InterfaceRequest<CookieStore> store) {
-  BindToRequest(new CookieStoreImpl(context_, origin_), &store);
+  new CookieStoreImpl(store.Pass(), context_, origin_);
 }
 
 void NetworkServiceImpl::CreateWebSocket(InterfaceRequest<WebSocket> socket) {
-  BindToRequest(new WebSocketImpl(context_), &socket);
+  new WebSocketImpl(socket.Pass(), context_);
 }
 
 void NetworkServiceImpl::CreateTCPBoundSocket(
     NetAddressPtr local_address,
     InterfaceRequest<TCPBoundSocket> bound_socket,
     const CreateTCPBoundSocketCallback& callback) {
-  scoped_ptr<TCPBoundSocketImpl> bound(new TCPBoundSocketImpl);
+  scoped_ptr<TCPBoundSocketImpl> bound(
+      new TCPBoundSocketImpl(bound_socket.Pass()));
   int net_error = bound->Bind(local_address.Pass());
   if (net_error != net::OK) {
     callback.Run(MakeNetworkError(net_error), NetAddressPtr());
     return;
   }
   NetAddressPtr resulting_local_address(bound->GetLocalAddress());
-  BindToRequest(bound.release(), &bound_socket);
+  // Release the implementation and let its lifecycle be managed by the pipe.
+  ignore_result(bound.release());
   callback.Run(MakeNetworkError(net::OK), resulting_local_address.Pass());
 }
 
 void NetworkServiceImpl::CreateTCPConnectedSocket(
     NetAddressPtr remote_address,
     ScopedDataPipeConsumerHandle send_stream,
     ScopedDataPipeProducerHandle receive_stream,
     InterfaceRequest<TCPConnectedSocket> client_socket,
     const CreateTCPConnectedSocketCallback& callback) {
   // TODO(brettw) implement this. We need to know what type of socket to use
@@ skipping 20 matching lines @@
 }
 
 void NetworkServiceImpl::CreateHostResolver(
     InterfaceRequest<HostResolver> host_resolver) {
   // The lifetime of this HostResolverImpl is bound to that of the underlying
   // pipe.
   new HostResolverImpl(host_resolver.Pass());
 }
 
 }  // namespace mojo