Remove uses of shell::Loader from content

content/browser/mojo/mojo_shell_context.cc

 // Copyright 2015 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 "content/browser/mojo/mojo_shell_context.h"
 
 #include <unordered_map>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/browser/gpu/gpu_process_host.h"
+#include "content/browser/mojo/browser_shell_connection.h"
 #include "content/browser/mojo/constants.h"
 #include "content/common/gpu_process_launch_causes.h"
 #include "content/common/mojo/mojo_shell_connection_impl.h"
-#include "content/common/mojo/static_loader.h"
 #include "content/common/process_control.mojom.h"
 #include "content/grit/content_resources.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/utility_process_host.h"
 #include "content/public/browser/utility_process_host_client.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/service_registry.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "mojo/public/cpp/bindings/string.h"
 #include "services/catalog/factory.h"
 #include "services/catalog/manifest_provider.h"
 #include "services/catalog/store.h"
 #include "services/shell/connect_params.h"
-#include "services/shell/loader.h"
 #include "services/shell/native_runner.h"
 #include "services/shell/public/cpp/identity.h"
 #include "services/shell/public/cpp/shell_client.h"
 #include "services/shell/public/interfaces/connector.mojom.h"
+#include "services/shell/public/interfaces/shell_client.mojom.h"
+#include "services/shell/public/interfaces/shell_client_factory.mojom.h"
 #include "services/shell/runner/host/in_process_native_runner.h"
 #include "services/user/public/cpp/constants.h"
 
 namespace content {
 
 namespace {
 
 // An extra set of apps to register on initialization, if set by a test.
 const MojoShellContext::StaticApplicationMap* g_applications_for_test;
 
@@ skipping 10 matching lines @@
 
   ServiceRegistry* services = process_host->GetServiceRegistry();
   services->ConnectToRemoteService(std::move(request));
 }
 
 void OnApplicationLoaded(const std::string& name, bool success) {
   if (!success)
     LOG(ERROR) << "Failed to launch Mojo application for " << name;
 }
 
-// This launches a utility process and forwards the Load request the
-// mojom::ProcessControl service there. The utility process is sandboxed iff
-// |use_sandbox| is true.
-class UtilityProcessLoader : public shell::Loader {
- public:
-  UtilityProcessLoader(const base::string16& process_name, bool use_sandbox)
-      : process_name_(process_name), use_sandbox_(use_sandbox) {}
-  ~UtilityProcessLoader() override {}
-
- private:
-  // shell::Loader:
-  void Load(const std::string& name,
-            shell::mojom::ShellClientRequest request) override {
-    mojom::ProcessControlPtr process_control;
-    auto process_request = mojo::GetProxy(&process_control);
-    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                            base::Bind(&StartUtilityProcessOnIOThread,
-                                       base::Passed(&process_request),
-                                       process_name_, use_sandbox_));
-    process_control->LoadApplication(name, std::move(request),
-                                     base::Bind(&OnApplicationLoaded, name));
-  }
-
-  const base::string16 process_name_;
-  const bool use_sandbox_;
-
-  DISALLOW_COPY_AND_ASSIGN(UtilityProcessLoader);
-};
+void LaunchAppInUtilityProcess(const std::string& app_name,
+                               const base::string16& process_name,
+                               bool use_sandbox,
+                               shell::mojom::ShellClientRequest request) {
+  mojom::ProcessControlPtr process_control;
+  mojom::ProcessControlRequest process_request =
+      mojo::GetProxy(&process_control);
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(&StartUtilityProcessOnIOThread,
+                                     base::Passed(&process_request),
+                                     process_name, use_sandbox));
+  process_control->LoadApplication(app_name, std::move(request),
+                                   base::Bind(&OnApplicationLoaded, app_name));
+}
 
 // Request mojom::ProcessControl from GPU process host. Must be called on IO
 // thread.
 void RequestGpuProcessControl(
     mojo::InterfaceRequest<mojom::ProcessControl> request) {
   BrowserChildProcessHostDelegate* process_host =
       GpuProcessHost::Get(GpuProcessHost::GPU_PROCESS_KIND_SANDBOXED,
                           CAUSE_FOR_GPU_LAUNCH_MOJO_SETUP);
   if (!process_host) {
     DLOG(ERROR) << "GPU process host not available.";
     return;
   }
 
   // TODO(xhwang): It's possible that |process_host| is non-null, but the actual
   // process is dead. In that case, |request| will be dropped and application
   // load requests through mojom::ProcessControl will also fail. Make sure we
   // handle
   // these cases correctly.
   process_host->GetServiceRegistry()->ConnectToRemoteService(
       std::move(request));
 }
 
-// Forwards the load request to the GPU process.
-class GpuProcessLoader : public shell::Loader {
- public:
-  GpuProcessLoader() {}
-  ~GpuProcessLoader() override {}
-
- private:
-  // shell::Loader:
-  void Load(const std::string& name,
-            shell::mojom::ShellClientRequest request) override {
-    mojom::ProcessControlPtr process_control;
-    auto process_request = mojo::GetProxy(&process_control);
-    BrowserThread::PostTask(
-        BrowserThread::IO, FROM_HERE,
-        base::Bind(&RequestGpuProcessControl, base::Passed(&process_request)));
-    process_control->LoadApplication(name, std::move(request),
-                                     base::Bind(&OnApplicationLoaded, name));
-  }
-
-  DISALLOW_COPY_AND_ASSIGN(GpuProcessLoader);
-};
+void LaunchAppInGpuProcess(const std::string& app_name,
+                           shell::mojom::ShellClientRequest request) {
+  mojom::ProcessControlPtr process_control;
+  mojom::ProcessControlRequest process_request =
+      mojo::GetProxy(&process_control);
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&RequestGpuProcessControl, base::Passed(&process_request)));
+  process_control->LoadApplication(app_name, std::move(request),
+                                   base::Bind(&OnApplicationLoaded, app_name));
+}
 
 }  // namespace
 
 // A ManifestProvider which resolves application names to builtin manifest
 // resources for the catalog service to consume.
 class MojoShellContext::BuiltinManifestProvider
     : public catalog::ManifestProvider {
  public:
   BuiltinManifestProvider() {}
   ~BuiltinManifestProvider() override {}
@@ skipping 55 matching lines @@
     }
   }
 
  private:
   MojoShellContext* shell_context_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(Proxy);
 };
 
+// Used to attach an existing ShellClient instance as a listener on the global
+// MojoShellConnection.
+// TODO(rockot): Find a way to get rid of this.
+class ShellConnectionListener : public MojoShellConnection::Listener {
+ public:
+  ShellConnectionListener(std::unique_ptr<shell::ShellClient> client)
+      : client_(std::move(client)) {}
+  ~ShellConnectionListener() override {}
+
+ private:
+  // MojoShellConnection::Listener:
+  bool AcceptConnection(shell::Connection* connection) override {
+    return client_->AcceptConnection(connection);
+  }
+
+  std::unique_ptr<shell::ShellClient> client_;
+
+  DISALLOW_COPY_AND_ASSIGN(ShellConnectionListener);
+};
+
 // static
 base::LazyInstance<std::unique_ptr<MojoShellContext::Proxy>>
     MojoShellContext::proxy_ = LAZY_INSTANCE_INITIALIZER;
 
 void MojoShellContext::SetApplicationsForTest(
     const StaticApplicationMap* apps) {
   g_applications_for_test = apps;
 }
 
 MojoShellContext::MojoShellContext() {
@@ skipping 13 matching lines @@
   manifest_provider_->AddManifestResource("mojo:catalog",
                                           IDR_MOJO_CATALOG_MANIFEST);
   manifest_provider_->AddManifestResource(user_service::kUserServiceName,
                                           IDR_MOJO_PROFILE_MANIFEST);
 
   catalog_.reset(new catalog::Factory(file_task_runner.get(), nullptr,
                                       manifest_provider_.get()));
   shell_.reset(new shell::Shell(std::move(native_runner_factory),
                                 catalog_->TakeShellClient()));
 
+  if (!IsRunningInMojoShell()) {
+    MojoShellConnection::Create(
+        shell_->InitInstanceForEmbedder(kBrowserMojoApplicationName),
+        false /* is_external */);
+  }
+
+  std::unique_ptr<BrowserShellConnection> browser_shell_connection(
+      new BrowserShellConnection);
+
   StaticApplicationMap apps;
   GetContentClient()->browser()->RegisterInProcessMojoApplications(&apps);
   if (g_applications_for_test) {
     // Add testing apps to the map, potentially overwriting whatever the
     // browser client registered.
     for (const auto& entry : *g_applications_for_test)
       apps[entry.first] = entry.second;
   }
   for (const auto& entry : apps) {
-    shell_->SetLoaderForName(base::WrapUnique(new StaticLoader(entry.second)),
-                             entry.first);
+    browser_shell_connection->AddEmbeddedApplication(
+        entry.first, entry.second, nullptr);
   }
 
   ContentBrowserClient::OutOfProcessMojoApplicationMap sandboxed_apps;
   GetContentClient()
       ->browser()
       ->RegisterOutOfProcessMojoApplications(&sandboxed_apps);
   for (const auto& app : sandboxed_apps) {
-    shell_->SetLoaderForName(base::WrapUnique(new UtilityProcessLoader(
-                                 app.second, true /* use_sandbox */)),
-                             app.first);
+    browser_shell_connection->AddShellClientRequestHandler(
+        app.first,
+        base::Bind(&LaunchAppInUtilityProcess, app.first, app.second,
+                   true /* use_sandbox */));
   }
 
   ContentBrowserClient::OutOfProcessMojoApplicationMap unsandboxed_apps;
   GetContentClient()
       ->browser()
       ->RegisterUnsandboxedOutOfProcessMojoApplications(&unsandboxed_apps);
   for (const auto& app : unsandboxed_apps) {
-    shell_->SetLoaderForName(base::WrapUnique(new UtilityProcessLoader(
-                                 app.second, false /* use_sandbox */)),
-                             app.first);
+    browser_shell_connection->AddShellClientRequestHandler(
+        app.first,
+        base::Bind(&LaunchAppInUtilityProcess, app.first, app.second,
+                   false /* use_sandbox */));
   }
 
 #if (ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
-  shell_->SetLoaderForName(base::WrapUnique(new GpuProcessLoader),
-                           "mojo:media");
+  browser_shell_connection->AddShellClientRequestHandler(
+      "mojo:media", base::Bind(&LaunchAppInGpuProcess, "mojo:media"));
 #endif
 
-  if (!IsRunningInMojoShell()) {
-    MojoShellConnection::Create(
-        shell_->InitInstanceForEmbedder(kBrowserMojoApplicationName),
-        false /* is_external */);
-  }
+  // Attach our ShellClientFactory implementation to the global connection.
+  MojoShellConnection* shell_connection = MojoShellConnection::Get();
+  CHECK(shell_connection);
+  shell_connection->AddListener(
+      new ShellConnectionListener(std::move(browser_shell_connection)));
 }
 
 MojoShellContext::~MojoShellContext() {
   if (!IsRunningInMojoShell())
     MojoShellConnectionImpl::Destroy();
 }
 
 // static
 void MojoShellContext::ConnectToApplication(
     const std::string& user_id,
@@ skipping 18 matching lines @@
   shell::Identity source_id(requestor_name, user_id);
   params->set_source(source_id);
   params->set_target(shell::Identity(name, user_id));
   params->set_remote_interfaces(std::move(request));
   params->set_local_interfaces(std::move(exposed_services));
   params->set_connect_callback(callback);
   shell_->Connect(std::move(params));
 }
 
 }  // namespace content