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,
+         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),
         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())));
+          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;
     }
 
     // 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(),

[Aaron Boodman, 2014/11/18 23:46:15]

It will be great when we pull NativeContentHandler out of this, it will
dramatically simplify this guy.

Then maybe we can also separate DynamicApplicationLoader into totally separate
NetworkLoader and LocalLoader subclasses of ApplicationLoader.

[qsr, 2014/11/19 13:42:38]

Acknowledged.

[Aaron Boodman, 2014/11/19 15:58:15]

I wonder if we could do a MojoLoader too, that resolves the mojo URL, then
delegates to NetworkLoader and LocalLoader.

            base::Bind(&Loader::RunLibrary, weak_ptr_factory_.GetWeakPtr()));
   }
 
   void ReportComplete() { loader_complete_callback_.Run(this); }
 
  private:
   bool PeekContentHandler(std::string* mojo_shebang,
                           GURL* mojo_content_handler_url) {
     std::string shebang;
     if (HasMojoMagic() && PeekFirstLine(&shebang)) {
       GURL url(shebang.substr(2, std::string::npos));
       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()));
   }
 
+  ScopedMessagePipeHandle shell_handle_;
   scoped_refptr<ApplicationLoader::LoadCallbacks> load_callbacks_;
   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,
               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),
         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,
                 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) {
     StartNetworkRequest(url, network_service);
   }
 
   ~NetworkLoader() override {
     if (!path_.empty())
       base::DeleteFile(path_, false);
   }
@@ skipping 97 matching lines @@
 
 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,
+    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;
   }
 
   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_callbacks, 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