Remove Client relationship between mojo.Shell/mojo.Application

shell/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 "shell/application_manager/application_manager.h"
 
 #include <stdio.h>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
@@ skipping 133 matching lines @@
                << requested_url.spec();
 }
 
 void ApplicationManager::ConnectToApplicationImpl(
     const GURL& requested_url,
     const GURL& resolved_url,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider> services,
     ServiceProviderPtr exposed_services,
     ApplicationLoader* loader) {
-  ShellPtr shell_ptr;
+  ApplicationPtr application;
+  InterfaceRequest<Application> application_request = GetProxy(&application);
   ShellImpl* shell =
-      new ShellImpl(GetProxy(&shell_ptr), this, requested_url, resolved_url);
+      new ShellImpl(application.Pass(), this, requested_url, resolved_url);
   url_to_shell_impl_[resolved_url] = shell;
-  shell->client()->Initialize(GetArgsForURL(requested_url));
+  shell->InitializeApplication(GetArgsForURL(requested_url));
 
-  loader->Load(this, resolved_url, shell_ptr.Pass(),
+  loader->Load(this, resolved_url, application_request.Pass(),
                base::Bind(&ApplicationManager::LoadWithContentHandler,
                           weak_ptr_factory_.GetWeakPtr()));
   ConnectToClient(shell, resolved_url, requestor_url, services.Pass(),
                   exposed_services.Pass());
 }
 
 ShellImpl* ApplicationManager::GetShellImpl(const GURL& url) {
   const auto& shell_it = url_to_shell_impl_.find(url);
   if (shell_it != url_to_shell_impl_.end())
     return shell_it->second;
   return nullptr;
 }
 
 void ApplicationManager::ConnectToClient(
     ShellImpl* shell_impl,
     const GURL& url,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider> services,
     ServiceProviderPtr exposed_services) {
   shell_impl->ConnectToClient(requestor_url, services.Pass(),
                               exposed_services.Pass());
 }
 
 void ApplicationManager::RegisterExternalApplication(
     const GURL& url,
     const std::vector<std::string>& args,
-    ScopedMessagePipeHandle shell_handle) {
-  ShellImpl* shell_impl =
-      new ShellImpl(MakeRequest<Shell>(shell_handle.Pass()), this, url, url);
+    ApplicationPtr application) {
+  ShellImpl* shell_impl = new ShellImpl(application.Pass(), this, url, url);
   url_to_shell_impl_[url] = shell_impl;
 
   if (args.empty())
-    shell_impl->client()->Initialize(GetArgsForURL(url));
+    shell_impl->InitializeApplication(GetArgsForURL(url));
   else
-    shell_impl->client()->Initialize(Array<String>::From(args));
+    shell_impl->InitializeApplication(Array<String>::From(args));
 }
 
 void ApplicationManager::LoadWithContentHandler(
     const GURL& content_handler_url,
-    ScopedMessagePipeHandle shell_handle,
+    InterfaceRequest<Application> application_request,
     URLResponsePtr url_response) {
   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;
   }
 
-  connection->content_handler()->StartApplication(
-      MakeProxy<Shell>(shell_handle.Pass()), url_response.Pass());
+  connection->content_handler()->StartApplication(application_request.Pass(),
+                                                  url_response.Pass());
 }
 
 void ApplicationManager::SetLoaderForURL(scoped_ptr<ApplicationLoader> loader,
                                          const GURL& url) {
   URLToLoaderMap::iterator it = url_to_loader_.find(url);
   if (it != url_to_loader_.end())
     delete it->second;
   url_to_loader_[url] = loader.release();
 }
 
@@ skipping 60 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