Add a user id parameter to connections

mojo/shell/application_manager.cc

 // Copyright 2014 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 "mojo/shell/application_manager.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 11 matching lines @@
 #include "mojo/shell/application_instance.h"
 #include "mojo/shell/connect_util.h"
 #include "mojo/shell/public/cpp/connect.h"
 #include "mojo/shell/public/cpp/shell_connection.h"
 #include "mojo/shell/switches.h"
 #include "mojo/util/filename_util.h"
 
 namespace mojo {
 namespace shell {
 
-namespace {
-
-class ShellApplicationLoader : public ApplicationLoader {
- public:
-  explicit ShellApplicationLoader(ApplicationManager* manager)
-      : manager_(manager) {}
-  ~ShellApplicationLoader() override {}
-
- private:
-  // Overridden from ApplicationLoader:
-  void Load(const GURL& url, mojom::ShellClientRequest request) override {
-    DCHECK(request.is_pending());
-    shell_connection_.reset(new ShellConnection(manager_, std::move(request)));
-  }
-
-  ApplicationManager* manager_;
-  scoped_ptr<ShellConnection> shell_connection_;
-
-  DISALLOW_COPY_AND_ASSIGN(ShellApplicationLoader);
-};
-
-}  // namespace
-
 // static
 ApplicationManager::TestAPI::TestAPI(ApplicationManager* manager)
     : manager_(manager) {
 }
 
 ApplicationManager::TestAPI::~TestAPI() {
 }
 
 bool ApplicationManager::TestAPI::HasRunningInstanceForURL(
     const GURL& url) const {
   return manager_->identity_to_instance_.find(Identity(url)) !=
          manager_->identity_to_instance_.end();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ApplicationManager, public:
 
 ApplicationManager::ApplicationManager(bool register_mojo_url_schemes)
     : ApplicationManager(nullptr, nullptr, register_mojo_url_schemes) {}
 
 ApplicationManager::ApplicationManager(
     scoped_ptr<NativeRunnerFactory> native_runner_factory,
     base::TaskRunner* task_runner,
     bool register_mojo_url_schemes)
     : task_runner_(task_runner),
       native_runner_factory_(std::move(native_runner_factory)),
       weak_ptr_factory_(this) {
-  SetLoaderForURL(make_scoped_ptr(new ShellApplicationLoader(this)),
-                  GURL("mojo://shell/"));
+  mojom::ShellClientRequest request;
+  CreateInstance(CreateShellIdentity(), &request);
+  shell_connection_.reset(new ShellConnection(this, std::move(request)));
 
   InitPackageManager(register_mojo_url_schemes);
 }
 
 ApplicationManager::~ApplicationManager() {
   TerminateShellConnections();
   STLDeleteValues(&url_to_loader_);
   for (auto& runner : native_runners_)
     runner.reset();
 }
 
 void ApplicationManager::SetInstanceQuitCallback(
     base::Callback<void(const Identity&)> callback) {
   instance_quit_callback_ = callback;
 }
 
 void ApplicationManager::Connect(scoped_ptr<ConnectParams> params) {
   TRACE_EVENT_INSTANT1("mojo_shell", "ApplicationManager::Connect",
                        TRACE_EVENT_SCOPE_THREAD, "original_url",
                        params->target().url().spec());
   DCHECK(params->target().url().is_valid());
 
+  if (params->target().user_id() == mojom::Shell::kUserInherit) {
+    ApplicationInstance* source = GetApplicationInstance(params->source());
+    CHECK(source);
+    Identity target = params->target();
+    target.set_user_id(source->identity().user_id());
+    params->set_target(target);
+  }
+
   // Connect to an existing matching instance, if possible.
   if (ConnectToExistingInstance(&params))
     return;
 
   std::string url = params->target().url().spec();
   shell_resolver_->ResolveMojoURL(
       url,
       base::Bind(&ApplicationManager::OnGotResolvedURL,
                   weak_ptr_factory_.GetWeakPtr(), base::Passed(&params)));
 }
@@ skipping 71 matching lines @@
 void ApplicationManager::CreateInstanceForHandle(
     ScopedHandle channel,
     const String& url,
     mojom::CapabilityFilterPtr filter,
     mojom::PIDReceiverRequest pid_receiver) {
   // We don't call ConnectToClient() here since the instance was created
   // manually by other code, not in response to a Connect() request. The newly
   // created instance is identified by |url| and may be subsequently reached by
   // client code using this identity.
   CapabilityFilter local_filter = filter->filter.To<CapabilityFilter>();
-  Identity target_id(url.To<GURL>(), std::string(), local_filter);
+  // TODO(beng): obtain userid from the inbound connection.
+  Identity target_id(url.To<GURL>(), std::string(), mojom::Shell::kUserInherit,
+                     local_filter);
   mojom::ShellClientRequest request;
   ApplicationInstance* instance = CreateInstance(target_id, &request);
   instance->BindPIDReceiver(std::move(pid_receiver));
   scoped_ptr<NativeRunner> runner =
       native_runner_factory_->Create(base::FilePath());
   runner->InitHost(std::move(channel), std::move(request));
   instance->SetNativeRunner(runner.get());
   native_runners_.push_back(std::move(runner));
 }
 
@@ skipping 20 matching lines @@
   loader->Load(url, std::move(request));
 
   SetLoaderForURL(std::move(loader), url);
 
   ConnectToInterface(this, CreateShellIdentity(), url, &shell_resolver_);
 }
 
 bool ApplicationManager::ConnectToExistingInstance(
     scoped_ptr<ConnectParams>* params) {
   ApplicationInstance* instance = GetApplicationInstance((*params)->target());
-  if (!instance)
-    return false;
+  if (!instance) {
+    Identity root_identity = (*params)->target();
+    root_identity.set_user_id(mojom::Shell::kUserRoot);
+    instance = GetApplicationInstance(root_identity);
+    if (!instance) return false;
+  }
   instance->ConnectToClient(std::move(*params));
   return true;
 }
 
 ApplicationInstance* ApplicationManager::CreateInstance(
     const Identity& target_id,
     mojom::ShellClientRequest* request) {
   mojom::ShellClientPtr shell_client;
   *request = GetProxy(&shell_client);
   ApplicationInstance* instance =
@@ skipping 58 matching lines @@
   // already in-progress and completed by the time this one did, and so the
   // requested application may already be running.
   if (ConnectToExistingInstance(&params))
     return;
 
   Identity source = params->source();
   CapabilityFilter filter = params->target().filter();
   // TODO(beng): this clobbers the filter passed via Connect().
   if (!base_filter.is_null())
     filter = base_filter->filter.To<CapabilityFilter>();
-  Identity target(params->target().url(), params->target().qualifier(), filter);
+  Identity target(params->target().url(), params->target().qualifier(),
+                  params->target().user_id(), filter);
 
   mojom::ShellClientRequest request;
   ApplicationInstance* instance = CreateInstance(target, &request);
   instance->ConnectToClient(std::move(params));
 
   if (LoadWithLoader(target, &request))
     return;
 
   CHECK(!file_url.is_null() && !base_filter.is_null());
 
   GURL resolved_gurl = resolved_url.To<GURL>();
   if (target.url().spec() != resolved_url) {
     // In cases where a package alias is resolved, we have to use the qualifier
     // from the original request rather than for the package itself, which will
     // always be the same.
     CreateShellClient(source,
-                      Identity(resolved_gurl, target.qualifier(), filter),
+                      Identity(resolved_gurl, target.qualifier(),
+                               target.user_id(), filter),
                       target.url(), std::move(request));
   } else {
     bool start_sandboxed = false;
     base::FilePath path = util::UrlToFilePath(file_url.To<GURL>());
     scoped_ptr<NativeRunner> runner = native_runner_factory_->Create(path);
     runner->Start(path, start_sandboxed, std::move(request),
                   base::Bind(&ApplicationManager::ApplicationPIDAvailable,
                              weak_ptr_factory_.GetWeakPtr(), instance->id()),
                   base::Bind(&ApplicationManager::CleanupRunner,
                              weak_ptr_factory_.GetWeakPtr(), runner.get()));
@@ skipping 35 matching lines @@
   info->qualifier = instance->identity().qualifier();
   if (instance->identity().url().spec() == "mojo://shell/")
     info->pid = base::Process::Current().Pid();
   else
     info->pid = instance->pid();
   return info;
 }
 
 }  // namespace shell
 }  // namespace mojo