Load application manifests from resources

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 <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/macros.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 "content/browser/gpu/gpu_process_host.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"
 #include "content/public/common/service_registry.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "mojo/public/cpp/bindings/string.h"
 #include "mojo/services/catalog/factory.h"
+#include "mojo/services/catalog/manifest_provider.h"
 #include "mojo/services/catalog/store.h"
 #include "mojo/shell/connect_params.h"
 #include "mojo/shell/loader.h"
 #include "mojo/shell/native_runner.h"
 #include "mojo/shell/public/cpp/identity.h"
 #include "mojo/shell/public/cpp/shell_client.h"
 #include "mojo/shell/public/interfaces/connector.mojom.h"
 #include "mojo/shell/runner/host/in_process_native_runner.h"
 
 namespace content {
 
 namespace {
 
-const char kBrowserAppName[] = "exe:chrome";
-
 // 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);
@@ skipping 90 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()->GetDataResourceBytes(id)->front_as<char>();
+}
+
 }  // 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 {}
+
+ 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 == "exe:content_browser") {

[Ben Goodger (Google), 2016/03/30 22:27:50]

this isn't affected if the embedder provides a different value in
GetPackagedApplicationName is it?

[Ken Rockot(use gerrit already), 2016/03/31 18:55:48]

If the embedder provides a different app name, they're also responsible for
providing the associated manifest if necessary.

+      *manifest_contents = GetStringResource(IDR_MOJO_CONTENT_BROWSER_MANIFEST);
+      return true;
+    } else if (name == "exe:content_renderer") {
+      *manifest_contents =
+          GetStringResource(IDR_MOJO_CONTENT_RENDERER_MANIFEST);
+      return true;
+    }
+
+    return GetContentClient()->browser()->GetMojoApplicationManifest(
+        name, manifest_contents);
+  }
+
+  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()) {}
 
   ~Proxy() {}
 
   void ConnectToApplication(
@@ skipping 40 matching lines @@
 MojoShellContext::MojoShellContext(
     scoped_refptr<base::SingleThreadTaskRunner> file_thread,
     scoped_refptr<base::SingleThreadTaskRunner> db_thread) {
   proxy_.Get().reset(new Proxy(this));
 
   scoped_refptr<base::SingleThreadTaskRunner> file_task_runner =
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE);
   scoped_ptr<mojo::shell::NativeRunnerFactory> native_runner_factory(
       new mojo::shell::InProcessNativeRunnerFactory(
           BrowserThread::GetBlockingPool()));
-  catalog_.reset(new catalog::Factory(file_task_runner.get(), nullptr));
+  manifest_provider_.reset(new BuiltinManifestProvider);
+  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(
       scoped_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
@@ skipping 36 matching lines @@
           switches::kMojoLocalStorage)) {
     base::Callback<scoped_ptr<mojo::ShellClient>()> profile_callback =
         base::Bind(&profile::CreateProfileApp, file_thread, db_thread);
     shell_->SetLoaderForName(
         make_scoped_ptr(new CurrentThreadLoader(profile_callback)),
         "mojo:profile");
   }
 
   if (!IsRunningInMojoShell()) {
     const bool is_external = false;
-    MojoShellConnection::Create(
-        shell_->InitInstanceForEmbedder(kBrowserAppName), is_external);
+    std::string app_name =
+        GetContentClient()->browser()->GetPackagedMojoApplicationName();
+    if (!app_name.empty()) {
+      MojoShellConnection::Create(
+          shell_->InitInstanceForEmbedder(app_name), is_external);
+    }
   }
 }
 
 MojoShellContext::~MojoShellContext() {
   if (!IsRunningInMojoShell())
     MojoShellConnectionImpl::Destroy();
 }
 
 // static
 void MojoShellContext::ConnectToApplication(
@@ skipping 19 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