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

mojo/shell/dynamic_application_loader.cc

Index: mojo/shell/dynamic_application_loader.cc
diff --git a/mojo/shell/dynamic_application_loader.cc b/mojo/shell/dynamic_application_loader.cc
index 7c578714da68d306bd905e0c66197143c0dc9ea3..bed70a48b33d31e0305a8278fe9969e62e77e6ed 100644
--- a/mojo/shell/dynamic_application_loader.cc
+++ b/mojo/shell/dynamic_application_loader.cc
@@ -53,9 +53,11 @@ class DynamicApplicationLoader::Loader {
   Loader(MimeTypeToURLMap* mime_type_to_url,
          Context* context,
          DynamicServiceRunnerFactory* runner_factory,
+         ScopedMessagePipeHandle shell_handle,
          scoped_refptr<ApplicationLoader::LoadCallbacks> load_callbacks,
          const LoaderCompleteCallback& loader_complete_callback)
-      : load_callbacks_(load_callbacks),
+      : shell_handle_(shell_handle.Pass()),
+        load_callbacks_(load_callbacks),
         loader_complete_callback_(loader_complete_callback),
         context_(context),
         mime_type_to_url_(mime_type_to_url),
@@ -84,15 +86,16 @@ class DynamicApplicationLoader::Loader {
     std::string shebang;
     if (PeekContentHandler(&shebang, &url)) {
       load_callbacks_->LoadWithContentHandler(
-          url, AsURLResponse(context_->task_runners()->blocking_pool(),
-                             static_cast<int>(shebang.size())));
+          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,
+          iter->second, shell_handle_.Pass(),
           AsURLResponse(context_->task_runners()->blocking_pool(), 0));
       return;
     }
@@ -124,12 +127,7 @@ class DynamicApplicationLoader::Loader {
   }
 
   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()
@@ -140,10 +138,11 @@ class DynamicApplicationLoader::Loader {
 
     runner_ = runner_factory_->Create(context_);
     runner_->Start(
-        path, shell_handle.Pass(),
+        path, shell_handle_.Pass(),
         base::Bind(&Loader::ReportComplete, weak_ptr_factory_.GetWeakPtr()));
   }
 
+  ScopedMessagePipeHandle shell_handle_;
   scoped_refptr<ApplicationLoader::LoadCallbacks> load_callbacks_;
   LoaderCompleteCallback loader_complete_callback_;
   Context* context_;
@@ -160,11 +159,13 @@ class DynamicApplicationLoader::LocalLoader : public Loader {
               MimeTypeToURLMap* mime_type_to_url,
               Context* context,
               DynamicServiceRunnerFactory* runner_factory,
+              ScopedMessagePipeHandle shell_handle,
               scoped_refptr<ApplicationLoader::LoadCallbacks> load_callbacks,
               const LoaderCompleteCallback& loader_complete_callback)
       : Loader(mime_type_to_url,
                context,
                runner_factory,
+               shell_handle.Pass(),
                load_callbacks,
                loader_complete_callback),
         url_(url),
@@ -246,11 +247,13 @@ class DynamicApplicationLoader::NetworkLoader : public Loader {
                 MimeTypeToURLMap* mime_type_to_url,
                 Context* context,
                 DynamicServiceRunnerFactory* runner_factory,
+                ScopedMessagePipeHandle shell_handle,
                 scoped_refptr<ApplicationLoader::LoadCallbacks> load_callbacks,
                 const LoaderCompleteCallback& loader_complete_callback)
       : Loader(mime_type_to_url,
                context,
                runner_factory,
+               shell_handle.Pass(),
                load_callbacks,
                loader_complete_callback),
         weak_ptr_factory_(this) {
@@ -368,11 +371,12 @@ void DynamicApplicationLoader::RegisterContentHandler(
 void DynamicApplicationLoader::Load(
     ApplicationManager* manager,
     const GURL& url,
+    ScopedMessagePipeHandle shell_handle,
     scoped_refptr<LoadCallbacks> load_callbacks) {
   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_callbacks, loader_complete_callback_));
     return;
   }
 
@@ -381,9 +385,10 @@ void DynamicApplicationLoader::Load(
         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_callbacks, loader_complete_callback_));
 }
 
 void DynamicApplicationLoader::OnApplicationError(ApplicationManager* manager,