Change userid from a uint32_t to a string guid

mojo/shell/public/interfaces/shell_client.mojom

 // 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.
 
 module mojo.shell.mojom;
 
 import "mojo/shell/public/interfaces/connector.mojom";
 import "mojo/shell/public/interfaces/interface_provider.mojom";
 
 // Implemented by something "known to" the Mojo Shell (e.g. an application or
 // service), for which an instance is tracked. It allows the implementor to
 // receive lifecycle events and service inbound connection attempts.
 interface ShellClient {
   // Called by the shell once an instance for this application has been created.
   // This method will be called exactly once before any other method is called.
   //
   // Parameters:
   //
   //  connector
   //    An interface back to the shell by which new connections may be
   //    established.
   //
   //  name
   //    The resolved name used in the connection request that resulted in this
   //    application being initialized.
   //
-  //  id
-  //    A unique identifier used by the shell to identify this instance.
-  //
   //  user_id
   //    Identifies the user this instance is run as in the shell. This may
   //    differ from the user the application that caused this application to be
   //    instantiated is run as. This will always be a valid user id, never
   //    Shell::kUserInherit.
   //
-  Initialize(Connector connector, string name, uint32 id, uint32 user_id);
+  //  id
+  //    A unique identifier used by the shell to identify this instance.
+  //
+  Initialize(Connector connector, string name, string user_id, uint32 id);
 
   // Called when another application attempts to open a connection to this
   // application. An application implements this method to complete the exchange
   // of interface implementations with the remote application. See also
   // documentation in shell.mojom for Connect(). The application originating
   // the request is referred to as the "source" and the one receiving the
   // "target".
   //
   // Parameters:
   //
   //  requestor_name
   //    The name of the source application.
   //
   //  requestor_id
   //    A unique identifier used by the shell to identify the source
   //    application's instance.
   //
   //  requestor_user_id
   //    An identifier for the user the source application is run as. This may
   //    differ from the application the target is run as (i.e. the one received
   //    via Initialize() above). This will always be a valid user id, never
-  //    Shell::kUserInherit.
+  //    kInheritUserID.
   //
   //  local_interfaces
   //    A request for an InterfaceProvider by which the source application may
   //    seek to bind interface implementations exported by the target.
   //
   //  remote_interfaces
   //    An InterfaceProvider by which the target application may bind interface
   //    implementations exported by the source.
   //
   //  allowed_interfaces
   //    A whitelist of interface names that should be exported to the source,
   //    according to the security policy described by the source and target's
   //    manifests. Attempts to bind interfaces not in this whitelist must not be
   //    fulfilled.
   //
   //  resolved_name
   //    The resolved name used to complete this connection.
   //
   AcceptConnection(string requestor_name,
+                   string requestor_user_id,
                    uint32 requestor_id,
-                   uint32 requestor_user_id,
                    InterfaceProvider&? local_interfaces,
                    InterfaceProvider? remote_interfaces,
                    array<string> allowed_interfaces,
                    string resolved_name);
 };