Remove support for Root identity singletons and rely on the all_users bit to be set. + test

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>
 
@@ skipping 301 matching lines @@
 
       if (!(*client_process_connection)->shell_client.is_valid() ||
           !(*client_process_connection)->pid_receiver_request.is_valid()) {
         LOG(ERROR) << "Error: must supply both shell_client AND "
                    << "pid_receiver_request when sending "
                    << "client_process_connection.";
         callback.Run(mojom::ConnectResult::INVALID_ARGUMENT,
                      mojom::kInheritUserID, mojom::kInvalidInstanceID);
         return false;
       }
-      if (shell_->GetExistingOrRootInstance(target)) {
+      if (shell_->GetExistingInstance(target)) {
         LOG(ERROR) << "Error: Cannot client process matching existing identity:"
                    << "Name: " << target.name() << " User: " << target.user_id()
                    << " Instance: " << target.instance();
         callback.Run(mojom::ConnectResult::INVALID_ARGUMENT,
                      mojom::kInheritUserID, mojom::kInvalidInstanceID);
         return false;
       }
     }
     return true;
   }
@@ skipping 220 matching lines @@
   mojom::ShellResolver* resolver_raw = resolver.get();
   resolver_raw->ResolveMojoName(
       name,
       base::Bind(&Shell::OnGotResolvedName, weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(std::move(resolver)), base::Passed(&params),
                  base::Passed(&client)));
 }
 
 Shell::Instance* Shell::GetExistingInstance(const Identity& identity) const {
   const auto& it = identity_to_instance_.find(identity);
-  return it != identity_to_instance_.end() ? it->second : nullptr;
-}
+  Instance* instance = it != identity_to_instance_.end() ? it->second : nullptr;
+  if (instance)
+    return instance;
 
-Shell::Instance* Shell::GetExistingOrRootInstance(
-    const Identity& identity) const {
-  Instance* instance = GetExistingInstance(identity);
-  if (!instance) {
-    if (singletons_.find(identity.name()) != singletons_.end()) {
-      for (auto entry : identity_to_instance_) {
-        if (entry.first.name() == identity.name() &&
-            entry.first.instance() == identity.instance()) {
-          return entry.second;
-        }
+  if (singletons_.find(identity.name()) != singletons_.end()) {
+    for (auto entry : identity_to_instance_) {
+      if (entry.first.name() == identity.name() &&
+          entry.first.instance() == identity.instance()) {
+        return entry.second;
       }
     }
-
-    Identity root_identity = identity;
-    root_identity.set_user_id(mojom::kRootUserID);
-    instance = GetExistingInstance(root_identity);
   }
-  return instance;
+  return nullptr;
 }
 
 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 = GetExistingOrRootInstance((*params)->target());
+  Instance* instance = GetExistingInstance((*params)->target());
   if (instance)
     instance->ConnectToClient(std::move(*params));
   return !!instance;
 }
 
 Shell::Instance* Shell::CreateInstance(const Identity& target,
                                        const CapabilitySpec& spec) {
   CHECK(target.user_id() != mojom::kInheritUserID);
   Instance* instance = new Instance(this, target, spec);
   DCHECK(identity_to_instance_.find(target) ==
@@ skipping 144 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