Make sure that Content Handled application can be connected multiple times.

mojo/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 "mojo/shell/dynamic_application_loader.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 35 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,
-         scoped_refptr<ApplicationLoader::LoadCallbacks> load_callbacks,
+         ScopedMessagePipeHandle shell_handle,
+         ApplicationLoader::LoadCallback load_callback,
          const LoaderCompleteCallback& loader_complete_callback)
-      : load_callbacks_(load_callbacks),
+      : shell_handle_(shell_handle.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_callbacks_->LoadWithContentHandler(
-          url, AsURLResponse(context_->task_runners()->blocking_pool(),
-                             static_cast<int>(shebang.size())));
+      load_callback_.Run(
+          url, shell_handle_.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_callbacks_->LoadWithContentHandler(
-          iter->second,
+      load_callback_.Run(
+          iter->second, shell_handle_.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) {
-    ScopedMessagePipeHandle shell_handle =
-        load_callbacks_->RegisterApplication();
-    if (!shell_handle.is_valid()) {
-      ReportComplete();
-      return;
-    }
+    DCHECK(shell_handle_.is_valid());
 
     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, shell_handle_.Pass(),
         base::Bind(&Loader::ReportComplete, weak_ptr_factory_.GetWeakPtr()));
   }
 
-  scoped_refptr<ApplicationLoader::LoadCallbacks> load_callbacks_;
+  ScopedMessagePipeHandle shell_handle_;
+  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,
-              scoped_refptr<ApplicationLoader::LoadCallbacks> load_callbacks,
+              ScopedMessagePipeHandle shell_handle,
+              ApplicationLoader::LoadCallback load_callback,
               const LoaderCompleteCallback& loader_complete_callback)
       : Loader(mime_type_to_url,
                context,
                runner_factory,
-               load_callbacks,
+               shell_handle.Pass(),
+               load_callback,
                loader_complete_callback),
         url_(url),
         path_(UrlToFile(url)) {
     Load();
   }
 
  private:
   static base::FilePath UrlToFile(const GURL& url) {
     DCHECK(url.SchemeIsFile());
     url::RawCanonOutputW<1024> output;
@@ skipping 60 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,
-                scoped_refptr<ApplicationLoader::LoadCallbacks> load_callbacks,
+                ScopedMessagePipeHandle shell_handle,
+                ApplicationLoader::LoadCallback load_callback,
                 const LoaderCompleteCallback& loader_complete_callback)
       : Loader(mime_type_to_url,
                context,
                runner_factory,
-               load_callbacks,
+               shell_handle.Pass(),
+               load_callback,
                loader_complete_callback),
         weak_ptr_factory_(this) {
     StartNetworkRequest(url, network_service);
   }
 
   ~NetworkLoader() override {
     if (!path_.empty())
       base::DeleteFile(path_, false);
   }
 
@@ skipping 93 matching lines @@
 
 DynamicApplicationLoader::~DynamicApplicationLoader() {
 }
 
 void DynamicApplicationLoader::RegisterContentHandler(
     const std::string& mime_type,
     const GURL& content_handler_url) {
   mime_type_to_url_[mime_type] = content_handler_url;
 }
 
-void DynamicApplicationLoader::Load(
-    ApplicationManager* manager,
-    const GURL& url,
-    scoped_refptr<LoadCallbacks> load_callbacks) {
+void DynamicApplicationLoader::Load(ApplicationManager* manager,
+                                    const GURL& url,
+                                    ScopedMessagePipeHandle shell_handle,
+                                    LoadCallback load_callback) {
   if (url.SchemeIsFile()) {
-    loaders_.push_back(new LocalLoader(url, &mime_type_to_url_, context_,
-                                       runner_factory_.get(), load_callbacks,
-                                       loader_complete_callback_));
+    loaders_.push_back(new LocalLoader(
+        url, &mime_type_to_url_, context_, runner_factory_.get(),
+        shell_handle.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(), load_callbacks, loader_complete_callback_));
+  loaders_.push_back(
+      new NetworkLoader(url, network_service_.get(), &mime_type_to_url_,
+                        context_, runner_factory_.get(), shell_handle.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