Use ShellClientFactory interface to load mojo:profile

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 "components/profile_service/profile_app.h"
+#include "components/profile_service/public/cpp/constants.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/browser/mojo/constants.h"
 #include "content/common/gpu_process_launch_causes.h"
-#include "content/common/mojo/current_thread_loader.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"
@@ skipping 31 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;
 }
 
-// The default loader to use for all applications. This does nothing but drop
-// the Application request.
-class DefaultLoader : public mojo::shell::Loader {
- public:
-   DefaultLoader() {}
-   ~DefaultLoader() override {}
-
- private:
-  // mojo::shell::Loader:
-  void Load(const std::string& name,
-            mojo::shell::mojom::ShellClientRequest request) override {}
-
-  DISALLOW_COPY_AND_ASSIGN(DefaultLoader);
-};
-
 // 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 mojo::shell::Loader {
  public:
   UtilityProcessLoader(const base::string16& process_name, bool use_sandbox)
       : process_name_(process_name), use_sandbox_(use_sandbox) {}
   ~UtilityProcessLoader() override {}
 
  private:
@@ skipping 52 matching lines @@
     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);
 };
 
-std::string GetStringResource(int id) {
-  return GetContentClient()->GetDataResource(
-      id, ui::ScaleFactor::SCALE_FACTOR_NONE).as_string();
-}
-
 }  // 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 {}
 
+  void AddManifestResource(const std::string& name, int resource_id) {
+    auto result = manifest_resources_.insert(
+        std::make_pair(name, resource_id));
+    DCHECK(result.second);
+  }
+
  private:
   // catalog::ManifestProvider:
   bool GetApplicationManifest(const base::StringPiece& name,
                               std::string* manifest_contents) override {
-    if (name == "mojo:catalog") {
-      *manifest_contents = GetStringResource(IDR_MOJO_CATALOG_MANIFEST);
-      return true;
-    } else if (name == kBrowserMojoApplicationName) {
-      *manifest_contents = GetStringResource(IDR_MOJO_CONTENT_BROWSER_MANIFEST);
-      return true;
-    } else if (name == kRendererMojoApplicationName) {
-      *manifest_contents =
-          GetStringResource(IDR_MOJO_CONTENT_RENDERER_MANIFEST);
-      return true;
-    }
+    auto it = manifest_resources_.find(name.as_string());
+    if (it == manifest_resources_.end())
+      return false;
+    *manifest_contents = GetContentClient()->GetDataResource(
+        it->second, ui::ScaleFactor::SCALE_FACTOR_NONE).as_string();
+    return true;
+  }
 
-    return false;
-  }
+  std::unordered_map<std::string, int> manifest_resources_;
 
   DISALLOW_COPY_AND_ASSIGN(BuiltinManifestProvider);
 };
 
 // Thread-safe proxy providing access to the shell context from any thread.
 class MojoShellContext::Proxy {
  public:
   Proxy(MojoShellContext* shell_context)
       : shell_context_(shell_context),
         task_runner_(base::ThreadTaskRunnerHandle::Get()) {}
@@ skipping 34 matching lines @@
 
 // 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(
-    scoped_refptr<base::SingleThreadTaskRunner> file_thread,
-    scoped_refptr<base::SingleThreadTaskRunner> db_thread) {
+MojoShellContext::MojoShellContext() {
   proxy_.Get().reset(new Proxy(this));
 
   scoped_refptr<base::SingleThreadTaskRunner> file_task_runner =
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE);
   std::unique_ptr<mojo::shell::NativeRunnerFactory> native_runner_factory(
       new mojo::shell::InProcessNativeRunnerFactory(
           BrowserThread::GetBlockingPool()));
+
   manifest_provider_.reset(new BuiltinManifestProvider);
+  manifest_provider_->AddManifestResource(kBrowserMojoApplicationName,
+                                          IDR_MOJO_CONTENT_BROWSER_MANIFEST);
+  manifest_provider_->AddManifestResource(kRendererMojoApplicationName,
+                                          IDR_MOJO_CONTENT_RENDERER_MANIFEST);
+  manifest_provider_->AddManifestResource("mojo:catalog",
+                                          IDR_MOJO_CATALOG_MANIFEST);
+  manifest_provider_->AddManifestResource(profile::kProfileMojoApplicationName,
+                                          IDR_MOJO_PROFILE_MANIFEST);
+
   catalog_.reset(new catalog::Factory(file_task_runner.get(), nullptr,
                                       manifest_provider_.get()));
   shell_.reset(new mojo::shell::Shell(std::move(native_runner_factory),
                                       catalog_->TakeShellClient()));
-  shell_->set_default_loader(
-      std::unique_ptr<mojo::shell::Loader>(new DefaultLoader));
 
   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) {
@@ skipping 19 matching lines @@
     shell_->SetLoaderForName(base::WrapUnique(new UtilityProcessLoader(
                                  app.second, false /* use_sandbox */)),
                              app.first);
   }
 
 #if (ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
   shell_->SetLoaderForName(base::WrapUnique(new GpuProcessLoader),
                            "mojo:media");
 #endif
 
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kMojoLocalStorage)) {
-    base::Callback<std::unique_ptr<mojo::ShellClient>()> profile_callback =
-        base::Bind(&profile::CreateProfileApp, file_thread, db_thread);
-    shell_->SetLoaderForName(
-        base::WrapUnique(new CurrentThreadLoader(profile_callback)),
-        "mojo:profile");
-  }
-
   if (!IsRunningInMojoShell()) {
     MojoShellConnection::Create(
         shell_->InitInstanceForEmbedder(kBrowserMojoApplicationName),
         false /* is_external */);
   }
 }
 
 MojoShellContext::~MojoShellContext() {
   if (!IsRunningInMojoShell())
     MojoShellConnectionImpl::Destroy();
@@ skipping 24 matching lines @@
   mojo::Identity source_id(requestor_name, user_id);
   params->set_source(source_id);
   params->set_target(mojo::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