mojo leveldb: Get profile and leveldb connected to DOMStorageContext.

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/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/leveldb/leveldb_app.h"
 #include "components/profile_service/profile_app.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/common/gpu/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/public/browser/browser_context.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/service_registry.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "mojo/public/cpp/bindings/string.h"
 #include "mojo/shell/connect_params.h"
 #include "mojo/shell/identity.h"
@@ skipping 121 matching lines @@
 // 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(
+      uint32_t user_id,
       const std::string& name,
       const std::string& requestor_name,
       mojo::shell::mojom::InterfaceProviderRequest request,
       mojo::shell::mojom::InterfaceProviderPtr exposed_services,
       const mojo::shell::mojom::Connector::ConnectCallback& callback) {
     if (task_runner_ == base::ThreadTaskRunnerHandle::Get()) {
       if (shell_context_) {
         shell_context_->ConnectToApplicationOnOwnThread(
-            name, requestor_name, std::move(request),
+            user_id, name, requestor_name, std::move(request),
             std::move(exposed_services), callback);
       }
     } else {
       // |shell_context_| outlives the main MessageLoop, so it's safe for it to
       // be unretained here.
       task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&MojoShellContext::ConnectToApplicationOnOwnThread,
-                     base::Unretained(shell_context_), name, requestor_name,
-                     base::Passed(&request), base::Passed(&exposed_services),
-                     callback));
+                     base::Unretained(shell_context_), user_id, name,
+                     requestor_name, base::Passed(&request),
+                     base::Passed(&exposed_services), callback));
     }
   }
 
  private:
   MojoShellContext* shell_context_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(Proxy);
 };
 
@@ skipping 53 matching lines @@
         make_scoped_ptr(
             new UtilityProcessLoader(app.second, false /* use_sandbox */)),
         app.first);
   }
 
 #if (ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
   application_manager_->SetLoaderForName(make_scoped_ptr(new GpuProcessLoader),
                                          "mojo:media");
 #endif
 
+  base::Callback<scoped_ptr<mojo::ShellClient>()> leveldb_callback =
+      base::Bind(&leveldb::CreateLevelDBApp);
+  application_manager_->SetLoaderForName(
+      make_scoped_ptr(new StaticLoader(leveldb_callback)),
+      "mojo:leveldb");
+
   base::Callback<scoped_ptr<mojo::ShellClient>()> profile_callback =
       base::Bind(&profile::CreateProfileApp);
   application_manager_->SetLoaderForName(
       make_scoped_ptr(new StaticLoader(profile_callback)), "mojo:profile");
 
   if (!IsRunningInMojoShell()) {
     MojoShellConnectionImpl::Create(
         application_manager_->InitInstanceForEmbedder(kBrowserAppName));
   }
 }
 
 MojoShellContext::~MojoShellContext() {
   if (!IsRunningInMojoShell())
     MojoShellConnectionImpl::Destroy();
 }
 
 // static
 void MojoShellContext::ConnectToApplication(
     const std::string& name,
     const std::string& requestor_name,
     mojo::shell::mojom::InterfaceProviderRequest request,
     mojo::shell::mojom::InterfaceProviderPtr exposed_services,
     const mojo::shell::mojom::Connector::ConnectCallback& callback) {
-  proxy_.Get()->ConnectToApplication(name, requestor_name, std::move(request),
-                                     std::move(exposed_services), callback);
+  // TODO(beng): kUserRoot is obviously wrong.
+  proxy_.Get()->ConnectToApplication(
+      mojo::shell::mojom::Connector::kUserRoot,

[Ben Goodger (Google), 2016/03/04 20:50:49]

this should be kUserInherit. Then the shell will figure out the right thing to
do.

+      name, requestor_name, std::move(request),
+      std::move(exposed_services), callback);
+}
+
+// static
+void MojoShellContext::ConnectToApplicationWithContext(
+    BrowserContext* context,

[Ben Goodger (Google), 2016/03/04 20:50:49]

rather than introduce knowledge of BrowserContext here, just make this method
take a uint32_t and push the burden of looking up the uid to the caller.

+    const std::string& name,
+    const std::string& requestor_name,
+    mojo::shell::mojom::InterfaceProviderRequest request,
+    mojo::shell::mojom::InterfaceProviderPtr exposed_services,
+    const mojo::shell::mojom::Connector::ConnectCallback& callback) {
+  uint32_t user_id = BrowserContext::GetMojoUserIdFor(context);
+  proxy_.Get()->ConnectToApplication(
+      user_id, name, requestor_name, std::move(request),
+      std::move(exposed_services), callback);
 }
 
 void MojoShellContext::ConnectToApplicationOnOwnThread(
+    uint32_t user_id,
     const std::string& name,
     const std::string& requestor_name,
     mojo::shell::mojom::InterfaceProviderRequest request,
     mojo::shell::mojom::InterfaceProviderPtr exposed_services,
     const mojo::shell::mojom::Connector::ConnectCallback& callback) {
   scoped_ptr<mojo::shell::ConnectParams> params(new mojo::shell::ConnectParams);
-  // TODO(beng): kUserRoot is obviously wrong.
   // TODO(beng): We need to set a permissive filter here temporarily because
   //             content is known as a bogus system: name that the application
   //             manager doesn't understand.
-  mojo::shell::Identity source_id(
-      requestor_name, std::string(), mojo::shell::mojom::Connector::kUserRoot);
+  mojo::shell::Identity source_id(requestor_name, std::string(), user_id);
   source_id.set_filter(mojo::shell::GetPermissiveCapabilityFilter());
   params->set_source(source_id);
   params->set_target(mojo::shell::Identity(
-      name, std::string(), mojo::shell::mojom::Connector::kUserRoot));
+      name, std::string(), user_id));
   params->set_remote_interfaces(std::move(request));
   params->set_local_interfaces(std::move(exposed_services));
   params->set_connect_callback(callback);
   application_manager_->Connect(std::move(params));
 }
 
 }  // namespace content