Move more of ContentHandler handling into PackageManager.

mojo/shell/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 "mojo/shell/application_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/trace_event/trace_event.h"
-#include "mojo/application/public/interfaces/content_handler.mojom.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/shell/application_instance.h"
-#include "mojo/shell/content_handler_connection.h"
 #include "mojo/shell/fetcher.h"
 #include "mojo/shell/package_manager.h"
 #include "mojo/shell/query_util.h"
 #include "mojo/shell/switches.h"
 
 namespace mojo {
 namespace shell {
 
 namespace {
 
@@ skipping 18 matching lines @@
 
 bool ApplicationManager::TestAPI::HasRunningInstanceForURL(
     const GURL& url) const {
   return manager_->identity_to_instance_.find(Identity(url)) !=
          manager_->identity_to_instance_.end();
 }
 
 ApplicationManager::ApplicationManager(
     scoped_ptr<PackageManager> package_manager)
     : package_manager_(package_manager.Pass()),
-      content_handler_id_counter_(0u),
+      task_runner_(nullptr),
+      weak_ptr_factory_(this) {
+  package_manager_->SetApplicationManager(this);
+}
+
+ApplicationManager::ApplicationManager(
+    scoped_ptr<PackageManager> package_manager,
+    scoped_ptr<NativeRunnerFactory> native_runner_factory,
+    base::TaskRunner* task_runner)
+    : package_manager_(package_manager.Pass()),
+      task_runner_(task_runner),
+      native_runner_factory_(native_runner_factory.Pass()),
       weak_ptr_factory_(this) {
   package_manager_->SetApplicationManager(this);
 }
 
 ApplicationManager::~ApplicationManager() {
-  IdentityToContentHandlerMap identity_to_content_handler(
-      identity_to_content_handler_);
-  for (auto& pair : identity_to_content_handler)
-    pair.second->CloseConnection();
   TerminateShellConnections();
   STLDeleteValues(&url_to_loader_);
 }
 
 void ApplicationManager::TerminateShellConnections() {
   STLDeleteValues(&identity_to_instance_);
 }
 
 void ApplicationManager::ConnectToApplication(
     scoped_ptr<ConnectToApplicationParams> params) {
@@ skipping 86 matching lines @@
     return;
 
   Identity source = params->source();
   Identity target = params->target();
   Shell::ConnectToApplicationCallback connect_callback =
       params->connect_callback();
   params->set_connect_callback(EmptyConnectCallback());
   ApplicationInstance* app = nullptr;
   InterfaceRequest<Application> request(CreateInstance(params.Pass(), &app));
 
+  uint32_t content_handler_id = package_manager_->HandleWithContentHandler(
+      fetcher.get(), source, target.url(), target.filter(), &request);
+  if (content_handler_id != Shell::kInvalidContentHandlerID) {
+    app->set_requesting_content_handler_id(content_handler_id);
+    connect_callback.Run(content_handler_id);
+    return;
+  }
 
-  GURL content_handler_url;
-  URLResponsePtr new_response;
-  std::string qualifier;
-  if (package_manager_->HandleWithContentHandler(fetcher.get(),
-                                                 target.url(),
-                                                 blocking_pool_,
-                                                 &new_response,
-                                                 &content_handler_url,
-                                                 &qualifier)) {
-    Identity content_handler(content_handler_url, qualifier, target.filter());
-    LoadWithContentHandler(source, content_handler, connect_callback, app,
-                           request.Pass(), new_response.Pass());
-  } else {
-    // TODO(erg): Have a better way of switching the sandbox on. For now, switch
-    // it on hard coded when we're using some of the sandboxable core services.
-    bool start_sandboxed = false;
-    if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
-            switches::kMojoNoSandbox)) {
-      start_sandboxed = (target.url() == GURL("mojo://core_services/") &&
-                            target.qualifier() == "Core") ||
-                        target.url() == GURL("mojo://html_viewer/");
-    }
+  // TODO(erg): Have a better way of switching the sandbox on. For now, switch
+  // it on hard coded when we're using some of the sandboxable core services.
+  bool start_sandboxed = false;
+  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kMojoNoSandbox)) {
+    start_sandboxed = (target.url() == GURL("mojo://core_services/") &&
+                          target.qualifier() == "Core") ||
+                      target.url() == GURL("mojo://html_viewer/");
+  }
 
-    connect_callback.Run(Shell::kInvalidContentHandlerID);
+  connect_callback.Run(Shell::kInvalidContentHandlerID);
 
-    fetcher->AsPath(blocking_pool_,
-                    base::Bind(&ApplicationManager::RunNativeApplication,
-                               weak_ptr_factory_.GetWeakPtr(),
-                               base::Passed(request.Pass()), start_sandboxed,
-                               base::Passed(fetcher.Pass())));
-  }
+  fetcher->AsPath(task_runner_,
+                  base::Bind(&ApplicationManager::RunNativeApplication,
+                              weak_ptr_factory_.GetWeakPtr(),
+                              base::Passed(request.Pass()), start_sandboxed,
+                              base::Passed(fetcher.Pass())));
 }
 
 void ApplicationManager::RunNativeApplication(
     InterfaceRequest<Application> application_request,
     bool start_sandboxed,
     scoped_ptr<Fetcher> fetcher,
     const base::FilePath& path,
     bool path_exists) {
   // We only passed fetcher to keep it alive. Done with it now.
   fetcher.reset();
 
   DCHECK(application_request.is_pending());
 
   if (!path_exists) {
     LOG(ERROR) << "Library not started because library path '" << path.value()
                << "' does not exist.";
     return;
   }
 
   TRACE_EVENT1("mojo_shell", "ApplicationManager::RunNativeApplication", "path",
                path.AsUTF8Unsafe());
   NativeRunner* runner = native_runner_factory_->Create().release();
   native_runners_.push_back(runner);
   runner->Start(path, start_sandboxed, application_request.Pass(),
                 base::Bind(&ApplicationManager::CleanupRunner,
                            weak_ptr_factory_.GetWeakPtr(), runner));
 }
 
-void ApplicationManager::LoadWithContentHandler(
-    const Identity& source,
-    const Identity& content_handler,
-    const Shell::ConnectToApplicationCallback& connect_callback,
-    ApplicationInstance* app,
-    InterfaceRequest<Application> application_request,
-    URLResponsePtr url_response) {
-  ContentHandlerConnection* connection = nullptr;
-  // TODO(beng): Figure out the extent to which capability filter should be
-  //             factored into handler identity.
-  IdentityToContentHandlerMap::iterator iter =
-      identity_to_content_handler_.find(content_handler);
-  if (iter != identity_to_content_handler_.end()) {
-    connection = iter->second;
-  } else {
-    connection = new ContentHandlerConnection(
-        this, source, content_handler, ++content_handler_id_counter_);
-    identity_to_content_handler_[content_handler] = connection;
-  }
-
-  app->set_requesting_content_handler_id(connection->id());
-  connection->content_handler()->StartApplication(application_request.Pass(),
-                                                  url_response.Pass());
-  connect_callback.Run(connection->id());
-}
-
 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();
 }
 
 ApplicationLoader* ApplicationManager::GetLoaderForURL(const GURL& url) {
   auto url_it = url_to_loader_.find(GetBaseURLAndQuery(url, nullptr));
   if (url_it != url_to_loader_.end())
     return url_it->second;
   return default_loader_.get();
 }
 
 void ApplicationManager::OnApplicationInstanceError(
     ApplicationInstance* instance) {
   // Called from ~ApplicationInstance, so we do not need to call Destroy here.
   const Identity identity = instance->identity();
   base::Closure on_application_end = instance->on_application_end();
   // Remove the shell.
   auto it = identity_to_instance_.find(identity);
   DCHECK(it != identity_to_instance_.end());
   delete it->second;
   identity_to_instance_.erase(it);
   if (!on_application_end.is_null())
     on_application_end.Run();
 }
 
-void ApplicationManager::OnContentHandlerConnectionClosed(
-    ContentHandlerConnection* content_handler) {
-  // Remove the mapping to the content handler.
-  auto it = identity_to_content_handler_.find(content_handler->identity());
-  DCHECK(it != identity_to_content_handler_.end());
-  identity_to_content_handler_.erase(it);
-}
-
 void ApplicationManager::CleanupRunner(NativeRunner* runner) {
   native_runners_.erase(
       std::find(native_runners_.begin(), native_runners_.end(), runner));
 }
 
 Shell::ConnectToApplicationCallback EmptyConnectCallback() {
   return base::Bind(&OnEmptyOnConnectCallback);
 }
 
 }  // namespace shell
 }  // namespace mojo