Revert of Remove shell::Loader

services/shell/shell.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 "services/shell/shell.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 102 matching lines @@
   Instance(shell::Shell* shell,
            const Identity& identity,
            const CapabilitySpec& capability_spec)
     : shell_(shell),
       id_(GenerateUniqueID()),
       identity_(identity),
       capability_spec_(capability_spec),
       allow_any_application_(capability_spec.required.count("*") == 1),
       pid_receiver_binding_(this),
       weak_factory_(this) {
-    if (identity_.name() == kShellName)
+    if (identity_.name() == kShellName ||
+        shell_->GetLoaderForName(identity_.name())) {
       pid_ = base::Process::Current().Pid();
+    }
     DCHECK_NE(mojom::kInvalidInstanceID, id_);
   }
 
   ~Instance() override {
     if (parent_)
       parent_->RemoveChild(this);
     // |children_| will be modified during destruction.
     std::set<Instance*> children = children_;
     for (auto child : children)
       shell_->OnInstanceError(child);
@@ skipping 316 matching lines @@
   instance->StartWithClient(std::move(client));
   singletons_.insert(kShellName);
   shell_connection_.reset(new ShellConnection(this, std::move(request)));
 
   if (catalog)
     InitCatalog(std::move(catalog));
 }
 
 Shell::~Shell() {
   TerminateShellConnections();
+  STLDeleteValues(&name_to_loader_);
   for (auto& runner : native_runners_)
     runner.reset();
 }
 
 void Shell::SetInstanceQuitCallback(
     base::Callback<void(const Identity&)> callback) {
   instance_quit_callback_ = callback;
 }
 
 void Shell::Connect(std::unique_ptr<ConnectParams> params) {
   Connect(std::move(params), nullptr);
 }
 
 mojom::ShellClientRequest Shell::InitInstanceForEmbedder(
     const std::string& name) {
   std::unique_ptr<ConnectParams> params(new ConnectParams);
 
   Identity embedder_identity(name, mojom::kRootUserID);
   params->set_source(embedder_identity);
   params->set_target(embedder_identity);
 
   mojom::ShellClientPtr client;
   mojom::ShellClientRequest request = mojo::GetProxy(&client);
   Connect(std::move(params), std::move(client));
 
   return request;
 }
 
+void Shell::SetLoaderForName(std::unique_ptr<Loader> loader,
+                             const std::string& name) {
+  auto it = name_to_loader_.find(name);
+  if (it != name_to_loader_.end())
+    delete it->second;
+  name_to_loader_[name] = loader.release();
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // Shell, ShellClient implementation:
 
 bool Shell::AcceptConnection(Connection* connection) {
   // The only interface we expose is mojom::Shell, and access to this interface
   // is brokered by a policy specific to each caller, managed by the caller's
   // instance. Here we look to see who's calling, and forward to the caller's
   // instance to continue.
   Instance* instance = nullptr;
   for (const auto& entry : identity_to_instance_) {
@@ skipping 220 matching lines @@
     // is already holding a corresponding ShellClientRequest.
     instance->StartWithClient(std::move(client));
   } else if (!client_process_connection.is_null()) {
     // Likewise if a ClientProcessConnection was given via Connect(), it
     // provides the ShellClient proxy to use.
     instance->StartWithClientProcessConnection(
         std::move(client_process_connection));
   } else {
     // Otherwise we create a new ShellClient pipe.
     mojom::ShellClientRequest request = GetProxy(&client);
-    CHECK(!result->package_url.is_null() && !result->capabilities.is_null());
+    if (LoadWithLoader(target, &request)) {
+      instance->StartWithClient(std::move(client));
+    } else {
+      CHECK(!result->package_url.is_null() && !result->capabilities.is_null());
 
-    if (target.name() != result->resolved_name) {
-      instance->StartWithClient(std::move(client));
-      Identity factory(result->resolved_name, target.user_id(),
-                       instance_name);
-      CreateShellClientWithFactory(factory, target.name(),
-                                   std::move(request));
-    } else {
-      instance->StartWithFilePath(
-          mojo::util::UrlToFilePath(result->package_url.To<GURL>()));
+      if (target.name() != result->resolved_name) {
+        instance->StartWithClient(std::move(client));
+        Identity factory(result->resolved_name, target.user_id(),
+                         instance_name);
+        CreateShellClientWithFactory(factory, target.name(),
+                                     std::move(request));
+      } else {
+        instance->StartWithFilePath(
+            mojo::util::UrlToFilePath(result->package_url.To<GURL>()));
+      }
     }
   }
 
   // Now that the instance has a ShellClient, we can connect to it.
   instance->ConnectToClient(std::move(params));
 }
 
+bool Shell::LoadWithLoader(const Identity& target,
+                           mojom::ShellClientRequest* request) {
+  Loader* loader = GetLoaderForName(target.name());
+  if (!loader)
+    return false;
+  loader->Load(target.name(), std::move(*request));
+  return true;
+}
+
+Loader* Shell::GetLoaderForName(const std::string& name) {
+  auto name_it = name_to_loader_.find(name);
+  if (name_it != name_to_loader_.end())
+    return name_it->second;
+  return default_loader_.get();
+}
+
 base::WeakPtr<Shell> Shell::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 void Shell::CleanupRunner(NativeRunner* runner) {
   for (auto it = native_runners_.begin(); it != native_runners_.end(); ++it) {
     if (it->get() == runner) {
       native_runners_.erase(it);
       return;
     }
   }
 }
 
 }  // namespace shell