Revert of Extract some stuff 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_fetcher.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 {
 
 // Used by TestAPI.
 bool has_created_instance = false;
@@ skipping 13 matching lines @@
 bool ApplicationManager::TestAPI::HasCreatedInstance() {
   return has_created_instance;
 }
 
 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()),
+ApplicationManager::ApplicationManager(scoped_ptr<ApplicationFetcher> fetcher)
+    : fetcher_(fetcher.Pass()),
       content_handler_id_counter_(0u),
       weak_ptr_factory_(this) {
-  package_manager_->SetApplicationManager(this);
+  fetcher_->SetApplicationManager(this);
 }
 
 ApplicationManager::~ApplicationManager() {
   URLToContentHandlerMap url_to_content_handler(url_to_content_handler_);
   for (auto& pair : url_to_content_handler)
     pair.second->CloseConnection();
   TerminateShellConnections();
   STLDeleteValues(&url_to_loader_);
 }
 
@@ skipping 32 matching lines @@
                        TRACE_EVENT_SCOPE_THREAD, "original_url",
                        original_url.spec());
   DCHECK(original_url.is_valid());
   DCHECK(original_url_request);
 
   // We need to look for running instances based on both the unresolved and
   // resolved urls.
   if (ConnectToRunningApplication(&params))
     return;
 
-  GURL resolved_url = package_manager_->ResolveURL(original_url);
+  GURL resolved_url = fetcher_->ResolveURL(original_url);
   params->SetURLInfo(resolved_url);
   if (ConnectToRunningApplication(&params))
     return;
 
   // The application is not running, let's compute the parameters.
   // NOTE: Set URL info using |original_url_request| instead of |original_url|
   // because it may contain more information (e.g., it is a POST request).
   params->SetURLInfo(original_url_request.Pass());
   ApplicationLoader* loader = GetLoaderForURL(resolved_url);
   if (loader) {
     ConnectToApplicationWithLoader(&params, resolved_url, loader);
     return;
   }
 
   original_url_request = params->TakeAppURLRequest();
   auto callback =
       base::Bind(&ApplicationManager::HandleFetchCallback,
                  weak_ptr_factory_.GetWeakPtr(), base::Passed(&params));
-  package_manager_->FetchRequest(original_url_request.Pass(), callback);
+  fetcher_->FetchRequest(original_url_request.Pass(), callback);
 }
 
 bool ApplicationManager::ConnectToRunningApplication(
     scoped_ptr<ConnectToApplicationParams>* params) {
   ApplicationInstance* instance = GetApplicationInstance(
       Identity((*params)->app_url(), (*params)->qualifier()));
   if (!instance)
     return false;
 
   instance->ConnectToClient(params->Pass());
@@ skipping 79 matching lines @@
   CapabilityFilter originator_filter = params->originator_filter();
   CapabilityFilter filter = params->filter();
   GURL app_url = params->app_url();
   std::string qualifier = params->qualifier();
   Shell::ConnectToApplicationCallback connect_callback =
       params->connect_callback();
   params->set_connect_callback(EmptyConnectCallback());
   ApplicationInstance* app = nullptr;
   InterfaceRequest<Application> request(RegisterInstance(params.Pass(), &app));
 
+  // For resources that are loaded with content handlers, we group app instances
+  // by site.
 
+  // If the response begins with a #!mojo <content-handler-url>, use it.
   GURL content_handler_url;
-  URLResponsePtr new_response;
-  if (package_manager_->HandleWithContentHandler(fetcher.get(),
-                                                 app_url,
-                                                 blocking_pool_,
-                                                 &new_response,
-                                                 &content_handler_url,
-                                                 &qualifier)) {
+  std::string shebang;
+  // TODO(beng): it seems like some delegate should/would want to have a say in
+  //             configuring the qualifier also.
+  bool enable_multi_process = base::CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kEnableMultiprocess);
+
+  if (fetcher->PeekContentHandler(&shebang, &content_handler_url)) {
+    URLResponsePtr response(fetcher->AsURLResponse(
+        blocking_pool_, static_cast<int>(shebang.size())));
+    std::string site =
+        enable_multi_process ? response->site.To<std::string>() : std::string();
     LoadWithContentHandler(originator_identity, originator_filter,
-                           content_handler_url, qualifier, filter,
-                           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)) {
-      if (app_url == GURL("mojo://core_services/") && qualifier == "Core")
-        start_sandboxed = true;
-      else if (app_url == GURL("mojo://html_viewer/"))
-        start_sandboxed = true;
+                           content_handler_url, site, filter, connect_callback,
+                           app, request.Pass(), response.Pass());
+    return;
+  }
+
+  MimeTypeToURLMap::iterator iter = mime_type_to_url_.find(fetcher->MimeType());
+  if (iter != mime_type_to_url_.end()) {
+    URLResponsePtr response(fetcher->AsURLResponse(blocking_pool_, 0));
+    std::string site =
+        enable_multi_process ? response->site.To<std::string>() : std::string();
+    LoadWithContentHandler(originator_identity, originator_filter, iter->second,
+                           site, filter, connect_callback, app, request.Pass(),
+                           response.Pass());
+    return;
+  }
+
+  auto alias_iter = application_package_alias_.find(app_url);
+  if (alias_iter != application_package_alias_.end()) {
+    // We replace the qualifier with the one our package alias requested.
+    URLResponsePtr response(URLResponse::New());
+    response->url = app_url.spec();
+
+    std::string qualifier;
+    if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kEnableMultiprocess)) {
+      // Why can't we use this in single process mode? Because of
+      // base::AtExitManager. If you link in ApplicationRunner into
+      // your code, and then we make initialize multiple copies of the
+      // application, we end up with multiple AtExitManagers and will check on
+      // the second one being created.
+      //
+      // Why doesn't that happen when running different apps? Because
+      // your_thing.mojo!base::AtExitManager and
+      // my_thing.mojo!base::AtExitManager are different symbols.
+      qualifier = alias_iter->second.second;
     }
 
-    connect_callback.Run(Shell::kInvalidContentHandlerID);
+    LoadWithContentHandler(originator_identity, originator_filter,
+                           alias_iter->second.first, qualifier, filter,
+                           connect_callback, app, request.Pass(),
+                           response.Pass());
+    return;
+  }
 
-    fetcher->AsPath(blocking_pool_,
-                    base::Bind(&ApplicationManager::RunNativeApplication,
-                               weak_ptr_factory_.GetWeakPtr(),
-                               base::Passed(request.Pass()), start_sandboxed,
-                               base::Passed(fetcher.Pass())));
+  // 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)) {
+    if (app_url == GURL("mojo://core_services/") && qualifier == "Core")
+      start_sandboxed = true;
+    else if (app_url == GURL("mojo://html_viewer/"))
+      start_sandboxed = true;
   }
+
+  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())));
 }
 
 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::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 ApplicationManager::RegisterApplicationPackageAlias(
+    const GURL& alias,
+    const GURL& content_handler_package,
+    const std::string& qualifier) {
+  application_package_alias_[alias] =
+      std::make_pair(content_handler_package, qualifier);
+}
+
 void ApplicationManager::LoadWithContentHandler(
     const Identity& originator_identity,
     const CapabilityFilter& originator_filter,
     const GURL& content_handler_url,
     const std::string& qualifier,
     const CapabilityFilter& filter,
     const Shell::ConnectToApplicationCallback& connect_callback,
     ApplicationInstance* app,
     InterfaceRequest<Application> application_request,
     URLResponsePtr url_response) {
@@ skipping 74 matching lines @@
   services->ConnectToService(interface_name, pipe.handle1.Pass());
   return pipe.handle0.Pass();
 }
 
 Shell::ConnectToApplicationCallback EmptyConnectCallback() {
   return base::Bind(&OnEmptyOnConnectCallback);
 }
 
 }  // namespace shell
 }  // namespace mojo