Remove Client relationship between mojo.Shell/mojo.Application

shell/dynamic_application_loader.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/dynamic_application_loader.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
@@ skipping 38 matching lines @@
 // Loader's lifetime.
 //
 // Async operations are done with WeakPtr to protect against
 // DynamicApplicationLoader going away (and taking all the Loaders with it)
 // while the async operation is outstanding.
 class DynamicApplicationLoader::Loader {
  public:
   Loader(MimeTypeToURLMap* mime_type_to_url,
          Context* context,
          DynamicServiceRunnerFactory* runner_factory,
-         ScopedMessagePipeHandle shell_handle,
+         InterfaceRequest<Application> application_request,
          ApplicationLoader::LoadCallback load_callback,
          const LoaderCompleteCallback& loader_complete_callback)
-      : shell_handle_(shell_handle.Pass()),
+      : application_request_(application_request.Pass()),
         load_callback_(load_callback),
         loader_complete_callback_(loader_complete_callback),
         context_(context),
         mime_type_to_url_(mime_type_to_url),
         runner_factory_(runner_factory),
         weak_ptr_factory_(this) {}
 
   virtual ~Loader() {}
 
  protected:
   virtual URLResponsePtr AsURLResponse(base::TaskRunner* task_runner,
                                        uint32_t skip) = 0;
 
   virtual void AsPath(
       base::TaskRunner* task_runner,
       base::Callback<void(const base::FilePath&, bool)> callback) = 0;
 
   virtual std::string MimeType() = 0;
 
   virtual bool HasMojoMagic() = 0;
 
   virtual bool PeekFirstLine(std::string* line) = 0;
 
   void Load() {
     // If the response begins with a #!mojo <content-handler-url>, use it.
     GURL url;
     std::string shebang;
     if (PeekContentHandler(&shebang, &url)) {
       load_callback_.Run(
-          url, shell_handle_.Pass(),
+          url, application_request_.Pass(),
           AsURLResponse(context_->task_runners()->blocking_pool(),
                         static_cast<int>(shebang.size())));
       return;
     }
 
     MimeTypeToURLMap::iterator iter = mime_type_to_url_->find(MimeType());
     if (iter != mime_type_to_url_->end()) {
       load_callback_.Run(
-          iter->second, shell_handle_.Pass(),
+          iter->second, application_request_.Pass(),
           AsURLResponse(context_->task_runners()->blocking_pool(), 0));
       return;
     }
 
     // TODO(aa): Sanity check that the thing we got looks vaguely like a mojo
     // application. That could either mean looking for the platform-specific dll
     // header, or looking for some specific mojo signature prepended to the
     // library.
 
     AsPath(context_->task_runners()->blocking_pool(),
@@ skipping 11 matching lines @@
       if (url.is_valid()) {
         *mojo_shebang = shebang;
         *mojo_content_handler_url = url;
         return true;
       }
     }
     return false;
   }
 
   void RunLibrary(const base::FilePath& path, bool path_exists) {
-    DCHECK(shell_handle_.is_valid());
+    DCHECK(application_request_.is_pending());
 
     if (!path_exists) {
       LOG(ERROR) << "Library not started because library path '" << path.value()
                  << "' does not exist.";
       ReportComplete();
       return;
     }
 
     runner_ = runner_factory_->Create(context_);
     runner_->Start(
-        path, shell_handle_.Pass(),
+        path, application_request_.Pass(),
         base::Bind(&Loader::ReportComplete, weak_ptr_factory_.GetWeakPtr()));
   }
 
-  ScopedMessagePipeHandle shell_handle_;
+  InterfaceRequest<Application> application_request_;
   ApplicationLoader::LoadCallback load_callback_;
   LoaderCompleteCallback loader_complete_callback_;
   Context* context_;
   MimeTypeToURLMap* mime_type_to_url_;
   DynamicServiceRunnerFactory* runner_factory_;
   scoped_ptr<DynamicServiceRunner> runner_;
   base::WeakPtrFactory<Loader> weak_ptr_factory_;
 };
 
 // A loader for local files.
 class DynamicApplicationLoader::LocalLoader : public Loader {
  public:
   LocalLoader(const GURL& url,
               MimeTypeToURLMap* mime_type_to_url,
               Context* context,
               DynamicServiceRunnerFactory* runner_factory,
-              ScopedMessagePipeHandle shell_handle,
+              InterfaceRequest<Application> application_request,
               ApplicationLoader::LoadCallback load_callback,
               const LoaderCompleteCallback& loader_complete_callback)
       : Loader(mime_type_to_url,
                context,
                runner_factory,
-               shell_handle.Pass(),
+               application_request.Pass(),
                load_callback,
                loader_complete_callback),
         url_(url),
         path_(UrlToFile(url)) {
     Load();
   }
 
  private:
   static base::FilePath UrlToFile(const GURL& url) {
     DCHECK(url.SchemeIsFile());
@@ skipping 61 matching lines @@
 };
 
 // A loader for network files.
 class DynamicApplicationLoader::NetworkLoader : public Loader {
  public:
   NetworkLoader(const GURL& url,
                 NetworkService* network_service,
                 MimeTypeToURLMap* mime_type_to_url,
                 Context* context,
                 DynamicServiceRunnerFactory* runner_factory,
-                ScopedMessagePipeHandle shell_handle,
+                InterfaceRequest<Application> application_request,
                 ApplicationLoader::LoadCallback load_callback,
                 const LoaderCompleteCallback& loader_complete_callback)
       : Loader(mime_type_to_url,
                context,
                runner_factory,
-               shell_handle.Pass(),
+               application_request.Pass(),
                load_callback,
                loader_complete_callback),
         url_(url),
         weak_ptr_factory_(this) {
     StartNetworkRequest(url, network_service);
   }
 
   ~NetworkLoader() override {
     if (!path_.empty())
       base::DeleteFile(path_, false);
@@ skipping 192 matching lines @@
 }
 
 void DynamicApplicationLoader::RegisterContentHandler(
     const std::string& mime_type,
     const GURL& content_handler_url) {
   DCHECK(content_handler_url.is_valid())
       << "Content handler URL is invalid for mime type " << mime_type;
   mime_type_to_url_[mime_type] = content_handler_url;
 }
 
-void DynamicApplicationLoader::Load(ApplicationManager* manager,
-                                    const GURL& url,
-                                    ShellPtr shell,
-                                    LoadCallback load_callback) {
+void DynamicApplicationLoader::Load(
+    ApplicationManager* manager,
+    const GURL& url,
+    InterfaceRequest<Application> application_request,
+    LoadCallback load_callback) {
   if (url.SchemeIsFile()) {
     loaders_.push_back(new LocalLoader(
         url, &mime_type_to_url_, context_, runner_factory_.get(),
-        shell.PassMessagePipe(), load_callback, loader_complete_callback_));
+        application_request.Pass(), load_callback, loader_complete_callback_));
     return;
   }
 
   if (!network_service_) {
     context_->application_manager()->ConnectToService(
         GURL("mojo:network_service"), &network_service_);
   }
 
   loaders_.push_back(new NetworkLoader(
       url, network_service_.get(), &mime_type_to_url_, context_,
-      runner_factory_.get(), shell.PassMessagePipe(), load_callback,
+      runner_factory_.get(), application_request.Pass(), load_callback,
       loader_complete_callback_));
 }
 
 void DynamicApplicationLoader::OnApplicationError(ApplicationManager* manager,
                                                   const GURL& url) {
   // TODO(darin): What should we do about service errors? This implies that
   // the app closed its handle to the service manager. Maybe we don't care?
 }
 
 void DynamicApplicationLoader::LoaderComplete(Loader* loader) {
   loaders_.erase(std::find(loaders_.begin(), loaders_.end(), loader));
 }
 
 }  // namespace shell
 }  // namespace mojo