Change userid from a uint32_t to a string guid

mojo/shell/shell.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/shell.h"
 
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
+#include "base/guid.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/process/process.h"
 #include "base/process/process_handle.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/trace_event/trace_event.h"
 #include "mojo/common/url_type_converters.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
@@ skipping 42 matching lines @@
         shell_->GetLoaderForName(identity_.name())) {
       pid_ = base::Process::Current().Pid();
     }
     DCHECK_NE(kInvalidApplicationID, id_);
   }
 
   ~Instance() override {}
 
   void InitializeClient() {
     shell_client_->Initialize(connectors_.CreateInterfacePtrAndBind(this),
-                              identity_.name(), id_, identity_.user_id());
+                              identity_.name(), identity_.user_id(), id_);
     connectors_.set_connection_error_handler(
         base::Bind(&mojo::shell::Shell::OnInstanceError,
                    base::Unretained(shell_), base::Unretained(this)));
   }
 
   void ConnectToClient(scoped_ptr<ConnectParams> params) {
-    params->connect_callback().Run(id_, identity_.user_id());
+    params->connect_callback().Run(identity_.user_id(), id_);
     AllowedInterfaces interfaces;
     interfaces.insert("*");
     if (!params->source().is_null())
       interfaces = GetAllowedInterfaces(params->source().filter(), identity_);
 
     Instance* source = shell_->GetExistingInstance(params->source());
     uint32_t source_id = source ? source->id() : kInvalidApplicationID;
     shell_client_->AcceptConnection(
-        params->source().name(), source_id, params->source().user_id(),
+        params->source().name(), params->source().user_id(), source_id,
         params->TakeRemoteInterfaces(), params->TakeLocalInterfaces(),
         Array<String>::From(interfaces), params->target().name());
   }
 
   scoped_ptr<NativeRunner> StartWithFileURL(const GURL& file_url,
                                             mojom::ShellClientRequest request,
                                             bool start_sandboxed,
                                             NativeRunnerFactory* factory) {
     base::FilePath path = util::UrlToFilePath(file_url);
     scoped_ptr<NativeRunner> runner = factory->Create(path);
@@ skipping 35 matching lines @@
 
   // ShellClient:
   bool AcceptConnection(Connection* connection) override {
     connection->AddInterface<mojom::Shell>(this);
     return true;
   }
 
  private:
   // mojom::Connector implementation:
   void Connect(const String& app_name,
-               uint32_t user_id,
+               const String& user_id,
                shell::mojom::InterfaceProviderRequest remote_interfaces,
                shell::mojom::InterfaceProviderPtr local_interfaces,
                const ConnectCallback& callback) override {
+    // TODO(beng): Might not want to CHECK here, but rather run the callback
+    // with an error code.
+    CHECK(base::IsValidGUID(user_id));
+
     // TODO(beng): perform checking on policy of whether this instance is
     // allowed to pass different user_ids.
     if (!IsValidName(app_name)) {
       LOG(ERROR) << "Error: invalid Name: " << app_name;
-      callback.Run(kInvalidApplicationID, kUserInherit);
+      callback.Run(mojom::kInheritUserID, kInvalidApplicationID);
       return;
     }
     if (allow_any_application_ ||
         identity_.filter().find(app_name) != identity_.filter().end()) {
       scoped_ptr<ConnectParams> params(new ConnectParams);
       params->set_source(identity_);
       params->set_target(Identity(app_name, std::string(), user_id));
       params->set_remote_interfaces(std::move(remote_interfaces));
       params->set_local_interfaces(std::move(local_interfaces));
       params->set_connect_callback(callback);
       shell_->Connect(std::move(params));
     }
     else {
       LOG(WARNING) << "CapabilityFilter prevented connection from: " <<
           identity_.name() << " to: " << app_name;
-      callback.Run(kInvalidApplicationID, kUserInherit);
+      callback.Run(mojom::kInheritUserID, kInvalidApplicationID);
     }
   }
   void Clone(mojom::ConnectorRequest request) override {
     connectors_.AddBinding(this, std::move(request));
   }
 
   // mojom::PIDReceiver:
   void SetPID(uint32_t pid) override {
     PIDAvailable(pid);
   }
 
   // InterfaceFactory<mojom::Shell>:
   void Create(Connection* connection,
               mojom::ShellRequest request) override {
     shell_bindings_.AddBinding(this, std::move(request));
   }
 
   // mojom::Shell implementation:
   void CreateInstanceForFactory(
       mojom::ShellClientFactoryPtr factory,
       const String& name,
-      uint32_t user_id,
+      const String& user_id,
       mojom::CapabilityFilterPtr filter,
       mojom::PIDReceiverRequest pid_receiver) override {
     // TODO(beng): perform checking on policy of whether this instance is
     // allowed to pass different user_ids.
-    if (user_id == mojom::Connector::kUserInherit)
-      user_id = identity_.user_id();
-    shell_->CreateInstanceForFactory(std::move(factory), name, user_id,
+    std::string user_id_string = user_id;
+    if (user_id_string == mojom::kInheritUserID)
+      user_id_string = identity_.user_id();
+    shell_->CreateInstanceForFactory(std::move(factory), name, user_id_string,
                                      std::move(filter),
                                      std::move(pid_receiver));
   }
   void AddInstanceListener(mojom::InstanceListenerPtr listener) override {
     // TODO(beng): this should only track the instances matching this user, and
     // root.
     shell_->AddInstanceListener(std::move(listener));
   }
 
   uint32_t GenerateUniqueID() const {
@@ skipping 62 matching lines @@
     base::Callback<void(const Identity&)> callback) {
   instance_quit_callback_ = callback;
 }
 
 void Shell::Connect(scoped_ptr<ConnectParams> params) {
   TRACE_EVENT_INSTANT1("mojo_shell", "Shell::Connect",
                        TRACE_EVENT_SCOPE_THREAD, "original_name",
                        params->target().name());
   DCHECK(IsValidName(params->target().name()));
 
-  if (params->target().user_id() == mojom::Connector::kUserInherit) {
+  if (params->target().user_id() == mojom::kInheritUserID) {
     Instance* source = GetExistingInstance(params->source());
     Identity target = params->target();
     // TODO(beng): we should CHECK source.
     target.set_user_id(source ? source->identity().user_id()
-                              : mojom::Connector::kUserRoot);
+                              : mojom::kRootUserID);
     params->set_target(target);
   }
 
   // Connect to an existing matching instance, if possible.
   if (ConnectToExistingInstance(&params))
     return;
 
   std::string name = params->target().name();
   shell_resolver_->ResolveMojoName(
       name,
       base::Bind(&Shell::OnGotResolvedName,
                  weak_ptr_factory_.GetWeakPtr(), base::Passed(&params)));
 }
 
 mojom::ShellClientRequest Shell::InitInstanceForEmbedder(
     const std::string& name) {
   DCHECK(!embedder_instance_);
 
-  mojo::shell::Identity target(name, std::string(),
-                               mojom::Connector::kUserRoot);
+  mojo::shell::Identity target(name, std::string(), mojom::kRootUserID);
   target.set_filter(GetPermissiveCapabilityFilter());
   DCHECK(!GetExistingInstance(target));
 
   mojom::ShellClientRequest request;
   embedder_instance_ = CreateInstance(target, &request);
   DCHECK(embedder_instance_);
 
   return request;
 }
 
@@ skipping 78 matching lines @@
 void Shell::NotifyPIDAvailable(uint32_t id, base::ProcessId pid) {
   instance_listeners_.ForAllPtrs([id, pid](mojom::InstanceListener* listener) {
                                    listener->InstancePIDAvailable(id, pid);
                                  });
 }
 
 bool Shell::ConnectToExistingInstance(scoped_ptr<ConnectParams>* params) {
   Instance* instance = GetExistingInstance((*params)->target());
   if (!instance) {
     Identity root_identity = (*params)->target();
-    root_identity.set_user_id(mojom::Connector::kUserRoot);
+    root_identity.set_user_id(mojom::kRootUserID);
     instance = GetExistingInstance(root_identity);
     if (!instance) return false;
   }
   instance->ConnectToClient(std::move(*params));
   return true;
 }
 
 Shell::Instance* Shell::CreateInstance(const Identity& target_id,
                                        mojom::ShellClientRequest* request) {
   mojom::ShellClientPtr shell_client;
   *request = GetProxy(&shell_client);
   Instance* instance = new Instance(std::move(shell_client), this, target_id);
   DCHECK(identity_to_instance_.find(target_id) ==
          identity_to_instance_.end());
   identity_to_instance_[target_id] = instance;
   mojom::InstanceInfoPtr info = instance->CreateInstanceInfo();
   instance_listeners_.ForAllPtrs(
       [this, &info](mojom::InstanceListener* listener) {
         listener->InstanceCreated(info.Clone());
       });
   instance->InitializeClient();
   return instance;
 }
 
 void Shell::CreateInstanceForFactory(
     mojom::ShellClientFactoryPtr factory,
-    const String& name,
-    uint32_t user_id,
+    const std::string& name,
+    const std::string& user_id,
     mojom::CapabilityFilterPtr filter,
     mojom::PIDReceiverRequest pid_receiver) {
-  DCHECK(user_id != mojom::Connector::kUserInherit);
+  DCHECK(user_id != mojom::kInheritUserID);
   // 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 |name| and may be subsequently reached by
   // client code using this identity.
-  Identity target_id(name, std::string(), mojom::Connector::kUserRoot);
+  Identity target_id(name, std::string(), mojom::kRootUserID);
   target_id.set_filter(filter->filter.To<CapabilityFilter>());
   mojom::ShellClientRequest request;
   Instance* instance = CreateInstance(target_id, &request);
   native_runners_.push_back(
       instance->StartWithFactory(std::move(factory), name, std::move(request),
                                  std::move(pid_receiver),
                                  native_runner_factory_.get()));
 }
 
 void Shell::AddInstanceListener(mojom::InstanceListenerPtr listener) {
@@ skipping 113 matching lines @@
   for (auto it = native_runners_.begin(); it != native_runners_.end(); ++it) {
     if (it->get() == runner) {
       native_runners_.erase(it);
       return;
     }
   }
 }
 
 }  // namespace shell
 }  // namespace mojo