Add a user id parameter to connections

mojo/shell/application_instance.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 "mojo/shell/application_instance.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 26 matching lines @@
 }
 
 ApplicationInstance::~ApplicationInstance() {
   for (auto request : queued_client_requests_)
     request->connect_callback().Run(kInvalidApplicationID);
   STLDeleteElements(&queued_client_requests_);
 }
 
 void ApplicationInstance::InitializeApplication() {
   shell_client_->Initialize(binding_.CreateInterfacePtrAndBind(),
-                            identity_.url().spec(), id_);
+                            identity_.url().spec(), id_, identity_.user_id());
   binding_.set_connection_error_handler([this]() { OnConnectionError(); });
 }
 
 void ApplicationInstance::ConnectToClient(scoped_ptr<ConnectParams> params) {
   if (queue_requests_) {
     queued_client_requests_.push_back(params.release());
     return;
   }
 
   CallAcceptConnection(std::move(params));
 }
 
 void ApplicationInstance::SetNativeRunner(NativeRunner* native_runner) {
   native_runner_ = native_runner;
 }
 
 void ApplicationInstance::BindPIDReceiver(
     InterfaceRequest<mojom::PIDReceiver> pid_receiver) {
   pid_receiver_binding_.Bind(std::move(pid_receiver));
 }
 
 // Shell implementation:
 void ApplicationInstance::Connect(
     const String& app_url,
+    uint32_t user_id,
     shell::mojom::InterfaceProviderRequest remote_interfaces,
     shell::mojom::InterfaceProviderPtr local_interfaces,
     mojom::CapabilityFilterPtr filter,
     const ConnectCallback& callback) {
   GURL url = app_url.To<GURL>();
   if (!url.is_valid()) {
     LOG(ERROR) << "Error: invalid URL: " << app_url;
     callback.Run(kInvalidApplicationID);
     return;
   }
   if (allow_any_application_ ||
       identity_.filter().find(url.spec()) != identity_.filter().end()) {
     CapabilityFilter capability_filter = GetPermissiveCapabilityFilter();
     if (!filter.is_null())
       capability_filter = filter->filter.To<CapabilityFilter>();
 
     scoped_ptr<ConnectParams> params(new ConnectParams);
-    params->SetSource(this);
-    params->set_target(Identity(url, std::string(), capability_filter));
+    params->set_source(identity_);
+    params->set_target(
+        Identity(url, std::string(), user_id, capability_filter));
     params->set_remote_interfaces(std::move(remote_interfaces));
     params->set_local_interfaces(std::move(local_interfaces));
     params->set_connect_callback(callback);
     manager_->Connect(std::move(params));
   } else {
     LOG(WARNING) << "CapabilityFilter prevented connection from: " <<
         identity_.url() << " to: " << url.spec();
     callback.Run(kInvalidApplicationID);
   }
 }
@@ skipping 22 matching lines @@
   params->connect_callback().Run(id_);
   AllowedInterfaces interfaces;
   interfaces.insert("*");
   if (!params->source().is_null())
     interfaces = GetAllowedInterfaces(params->source().filter(), identity_);
 
   ApplicationInstance* source =
       manager_->GetApplicationInstance(params->source());
   uint32_t source_id = source ? source->id() : Shell::kInvalidApplicationID;
   shell_client_->AcceptConnection(
-      params->source().url().spec(), source_id, params->TakeRemoteInterfaces(),
-      params->TakeLocalInterfaces(), Array<String>::From(interfaces),
-      params->target().url().spec());
+      params->source().url().spec(), params->source().user_id(), source_id,
+      params->TakeRemoteInterfaces(), params->TakeLocalInterfaces(),
+      Array<String>::From(interfaces), params->target().url().spec());
 }
 
 void ApplicationInstance::OnConnectionError() {
   std::vector<ConnectParams*> queued_client_requests;
   queued_client_requests_.swap(queued_client_requests);
   auto manager = manager_;
   manager_->OnApplicationInstanceError(this);
   //|this| is deleted.
 
   // If any queued requests came to shell during time it was shutting down,
   // start them now.
   for (auto request : queued_client_requests)
     manager->Connect(make_scoped_ptr(request));
 }
 
 void ApplicationInstance::OnQuitRequestedResult(bool can_quit) {
   if (can_quit)
     return;
 
   queue_requests_ = false;
   for (auto request : queued_client_requests_)
     CallAcceptConnection(make_scoped_ptr(request));
 
   queued_client_requests_.clear();
 }
 
 }  // namespace shell
 }  // namespace mojo