Enable content embedders to specify mojo application task runner.

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"
@@ skipping 30 matching lines @@
 #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;
-
 void StartUtilityProcessOnIOThread(
     mojo::InterfaceRequest<mojom::ProcessControl> request,
     const base::string16& process_name,
     bool use_sandbox) {
   UtilityProcessHost* process_host =
       UtilityProcessHost::Create(nullptr, nullptr);
   process_host->SetName(process_name);
   if (!use_sandbox)
     process_host->DisableSandbox();
   process_host->Start();
@@ skipping 151 matching lines @@
 
   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() {
   proxy_.Get().reset(new Proxy(this));
 
   scoped_refptr<base::SingleThreadTaskRunner> file_task_runner =
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE);
   std::unique_ptr<shell::NativeRunnerFactory> native_runner_factory(
       new shell::InProcessNativeRunnerFactory(
           BrowserThread::GetBlockingPool()));
 
   manifest_provider_.reset(new BuiltinManifestProvider);
@@ skipping 13 matching lines @@
     shell_.reset(new shell::Shell(std::move(native_runner_factory),
                                   catalog_->TakeShellClient()));
     MojoShellConnection::Create(
         shell_->InitInstanceForEmbedder(kBrowserMojoApplicationName),
         false /* is_external */);
   }
 
   std::unique_ptr<BrowserShellConnection> browser_shell_connection(
       new BrowserShellConnection);
 
-  StaticApplicationMap apps;
+  ContentBrowserClient::StaticMojoApplicationMap 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) {
     browser_shell_connection->AddEmbeddedApplication(
-        entry.first, entry.second, nullptr);
+        entry.first, entry.second.application_factory,
+        entry.second.application_task_runner);
   }
 
   ContentBrowserClient::OutOfProcessMojoApplicationMap sandboxed_apps;
   GetContentClient()
       ->browser()
       ->RegisterOutOfProcessMojoApplications(&sandboxed_apps);
   for (const auto& app : sandboxed_apps) {
     browser_shell_connection->AddShellClientRequestHandler(
         app.first,
         base::Bind(&LaunchAppInUtilityProcess, app.first, app.second,
@@ skipping 53 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