Add mojo::Binding<Interface> for more flexible pipe<->impl binding

mojo/application_manager/application_manager.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/application_manager/application_manager.h"
 
 #include <stdio.h>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/stl_util.h"
 #include "mojo/application_manager/application_loader.h"
 #include "mojo/common/common_type_converters.h"
 #include "mojo/public/cpp/application/connect.h"
+#include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/error_handler.h"
 #include "mojo/public/interfaces/application/application.mojom.h"
 #include "mojo/public/interfaces/application/shell.mojom.h"
 #include "mojo/services/public/interfaces/content_handler/content_handler.mojom.h"
 
 namespace mojo {
 
 namespace {
 // Used by TestAPI.
 bool has_created_instance = false;
@@ skipping 64 matching lines @@
     }
   }
 
   base::WeakPtr<ApplicationManager> manager_;
   GURL requested_url_;
   GURL resolved_url_;
   GURL requestor_url_;
   ServiceProviderPtr service_provider_;
 };
 
-class ApplicationManager::ShellImpl : public InterfaceImpl<Shell> {
+class ApplicationManager::ShellImpl : public Shell, public ErrorHandler {
  public:
-  ShellImpl(ApplicationManager* manager,
+  ShellImpl(ScopedMessagePipeHandle handle,
+            ApplicationManager* manager,
             const GURL& requested_url,
             const GURL& url)
-      : manager_(manager), requested_url_(requested_url), url_(url) {}
+      : ShellImpl(manager, requested_url, url) {
+    binding_.Bind(handle.Pass());
+  }
+
+  ShellImpl(ShellPtr* ptr,
+            ApplicationManager* manager,
+            const GURL& requested_url,
+            const GURL& url)
+      : ShellImpl(manager, requested_url, url) {
+    binding_.Bind(ptr);
+  }
 
   ~ShellImpl() override {}
 
   void ConnectToClient(const GURL& requestor_url,
                        ServiceProviderPtr service_provider) {
     client()->AcceptConnection(String::From(requestor_url),
                                service_provider.Pass());
   }
 
-  // ServiceProvider implementation:
+  Application* client() { return binding_.client(); }
+  const GURL& url() const { return url_; }
+  const GURL& requested_url() const { return requested_url_; }
+
+ private:
+  ShellImpl(ApplicationManager* manager,
+            const GURL& requested_url,
+            const GURL& url)
+      : manager_(manager),
+        requested_url_(requested_url),
+        url_(url),
+        binding_(this) {
+    binding_.set_error_handler(this);
+  }
+
+  // Shell implementation:
   void ConnectToApplication(
       const String& app_url,
       InterfaceRequest<ServiceProvider> in_service_provider) override {
     ServiceProviderPtr out_service_provider;
     out_service_provider.Bind(in_service_provider.PassMessagePipe());
     manager_->ConnectToApplication(
         app_url.To<GURL>(), url_, out_service_provider.Pass());
   }
 
-  const GURL& url() const { return url_; }
-  const GURL& requested_url() const { return requested_url_; }
-
- private:
+  // ErrorHandler implementation:
   void OnConnectionError() override { manager_->OnShellImplError(this); }
 
   ApplicationManager* const manager_;
   const GURL requested_url_;
   const GURL url_;
+  Binding<Shell> binding_;
 
   DISALLOW_COPY_AND_ASSIGN(ShellImpl);
 };
 
 class ApplicationManager::ContentHandlerConnection : public ErrorHandler {
  public:
   ContentHandlerConnection(ApplicationManager* manager,
                            const GURL& content_handler_url)
       : manager_(manager), content_handler_url_(content_handler_url) {
     ServiceProviderPtr service_provider;
@@ skipping 109 matching lines @@
         requestor_url,
         interceptor_->OnConnectToClient(url, service_provider.Pass()));
   } else {
     shell_impl->ConnectToClient(requestor_url, service_provider.Pass());
   }
 }
 
 void ApplicationManager::RegisterExternalApplication(
     const GURL& url,
     ScopedMessagePipeHandle shell_handle) {
-  url_to_shell_impl_[url] =
-      WeakBindToPipe(new ShellImpl(this, url, url), shell_handle.Pass());
+  url_to_shell_impl_[url] = new ShellImpl(shell_handle.Pass(), this, url, url);
 }
 
 void ApplicationManager::RegisterLoadedApplication(
     const GURL& requested_url,
     const GURL& resolved_url,
     const GURL& requestor_url,
     ServiceProviderPtr service_provider,
     ScopedMessagePipeHandle* shell_handle) {
   ShellImpl* shell_impl = NULL;
   URLToShellImplMap::iterator iter = url_to_shell_impl_.find(resolved_url);
   if (iter != url_to_shell_impl_.end()) {
     // This can happen because services are loaded asynchronously. So if we get
     // two requests for the same service close to each other, we might get here
     // and find that we already have it.
     shell_impl = iter->second;
   } else {
     MessagePipe pipe;
-    shell_impl = WeakBindToPipe(
-        new ShellImpl(this, requested_url, resolved_url), pipe.handle1.Pass());
+    shell_impl =
+        new ShellImpl(pipe.handle1.Pass(), this, requested_url, resolved_url);
     url_to_shell_impl_[resolved_url] = shell_impl;
     *shell_handle = pipe.handle0.Pass();
     shell_impl->client()->Initialize(GetArgsForURL(requested_url));
   }
 
   ConnectToClient(shell_impl, resolved_url, requestor_url,
                   service_provider.Pass());
 }
 
 void ApplicationManager::LoadWithContentHandler(
     const GURL& requested_url,
     const GURL& resolved_url,
     const GURL& requestor_url,
     const GURL& content_handler_url,
     URLResponsePtr url_response,
     ServiceProviderPtr service_provider) {
   ContentHandlerConnection* connection = NULL;
   URLToContentHandlerMap::iterator iter =
       url_to_content_handler_.find(content_handler_url);
   if (iter != url_to_content_handler_.end()) {
     connection = iter->second;
   } else {
     connection = new ContentHandlerConnection(this, content_handler_url);
     url_to_content_handler_[content_handler_url] = connection;
   }
 
   ShellPtr shell_proxy;
-  ShellImpl* shell_impl = WeakBindToProxy(
-      new ShellImpl(this, requested_url, resolved_url), &shell_proxy);
+  ShellImpl* shell_impl =
+      new ShellImpl(&shell_proxy, this, requested_url, resolved_url);
   content_shell_impls_.insert(shell_impl);
   shell_impl->client()->Initialize(GetArgsForURL(requested_url));
 
   connection->content_handler()->StartApplication(shell_proxy.Pass(),
                                                   url_response.Pass());
   ConnectToClient(
       shell_impl, resolved_url, requestor_url, service_provider.Pass());
 }
 
 void ApplicationManager::SetLoaderForURL(scoped_ptr<ApplicationLoader> loader,
@@ skipping 80 matching lines @@
   return pipe.handle0.Pass();
 }
 
 Array<String> ApplicationManager::GetArgsForURL(const GURL& url) {
   URLToArgsMap::const_iterator args_it = url_to_args_.find(url);
   if (args_it != url_to_args_.end())
     return Array<String>::From(args_it->second);
   return Array<String>();
 }
 }  // namespace mojo