Mus experiment in content shell on Android.

services/service_manager/service_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 "services/service_manager/service_manager.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 226 matching lines @@
     info->id = id_;
     info->identity = identity_;
     info->pid = pid_;
     return info;
   }
 
   const InterfaceProviderSpec& connection_spec() const {
     return connection_spec_;
   }
   const Identity& identity() const { return identity_; }
+  void set_identity(const Identity& identity) { identity_ = identity; }
   uint32_t id() const { return id_; }
 
   // Service:
   bool OnConnect(const Identity& remote_identity,
                  InterfaceRegistry* registry) override {
     Instance* source = service_manager_->GetExistingInstance(remote_identity);
     DCHECK(source);
     if (HasCapability(source->connection_spec_, kCapability_ServiceManager)) {
       registry->AddInterface<mojom::ServiceManager>(this);
       return true;
@@ skipping 196 matching lines @@
 
     service_manager_->OnInstanceError(this);
   }
 
   service_manager::ServiceManager* const service_manager_;
 
   // An id that identifies this instance. Distinct from pid, as a single process
   // may vend multiple application instances, and this object may exist before a
   // process is launched.
   const uint32_t id_;
-  const Identity identity_;
+  Identity identity_;
   const InterfaceProviderSpec connection_spec_;
   const bool allow_any_application_;
   std::unique_ptr<NativeRunner> runner_;
   mojom::ServicePtr service_;
   mojo::Binding<mojom::PIDReceiver> pid_receiver_binding_;
   mojo::BindingSet<mojom::Connector> connectors_;
   mojo::BindingSet<mojom::ServiceManager> service_manager_bindings_;
   base::ProcessId pid_ = base::kNullProcessId;
   Instance* parent_ = nullptr;
   InstanceMap children_;
@@ skipping 319 matching lines @@
   if (instance_name == GetNamePath(params->target().name()) &&
       result->qualifier != GetNamePath(result->resolved_name)) {
     instance_name = result->qualifier;
   }
   // |result->connection_spec| can be null when there is no manifest, e.g. for
   // URL types not resolvable by the resolver.
   InterfaceProviderSpec connection_spec = GetPermissiveInterfaceProviderSpec();
   if (result->connection_spec.has_value())
     connection_spec = result->connection_spec.value();
 
+  const Identity original_target(params->target());
   const std::string user_id =
       HasCapability(connection_spec, kCapability_AllUsers)
           ? base::GenerateGUID() : params->target().user_id();
   const Identity target(params->target().name(), user_id, instance_name);
   params->set_target(target);
 
   // It's possible that when this manifest request was issued, another one was
   // already in-progress and completed by the time this one did, and so the
   // requested application may already be running.
   if (ConnectToExistingInstance(&params))
@@ skipping 30 matching lines @@
     // Likewise if a ClientProcessConnection was given via Connect(), it
     // provides the Service proxy to use.
     instance->StartWithClientProcessConnection(
         std::move(client_process_connection));
   } else {
     // Otherwise we create a new Service pipe.
     mojom::ServiceRequest request = GetProxy(&service);
     CHECK(!result->package_path.empty() && result->connection_spec.has_value());
 
     if (target.name() != result->resolved_name) {
+      // When part of a packaged app, use the original user ID.
+      Identity packaged_app_target(target);
+      packaged_app_target.set_user_id(original_target.user_id());
+      instance->set_identity(packaged_app_target);
       instance->StartWithService(std::move(service));
-      Identity factory(result->resolved_name, target.user_id(),
+      Identity factory(result->resolved_name, original_target.user_id(),
                        instance_name);
       CreateServiceWithFactory(factory, target.name(), std::move(request));
     } else {
       base::FilePath package_path;
       if (!service_overrides_ || !service_overrides_->GetExecutablePathOverride(
             target.name(), &package_path)) {
         package_path = result->package_path;
       }
 
       Identity source_instance_identity;
@@ skipping 16 matching lines @@
   // Now that the instance has a Service, we can connect to it.
   bool connected = instance->ConnectToService(&params);
   DCHECK(connected);
 }
 
 base::WeakPtr<ServiceManager> ServiceManager::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 }  // namespace service_manager