Change userid from a uint32_t to a string guid

components/mus/ws/display.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 "components/mus/ws/display.h"
 
 #include "base/debug/debugger.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/mus/common/types.h"
 #include "components/mus/ws/connection_manager.h"
 #include "components/mus/ws/connection_manager_delegate.h"
 #include "components/mus/ws/display_binding.h"
 #include "components/mus/ws/focus_controller.h"
 #include "components/mus/ws/platform_display.h"
 #include "components/mus/ws/window_manager_factory_service.h"
 #include "components/mus/ws/window_manager_state.h"
 #include "components/mus/ws/window_tree.h"
 #include "components/mus/ws/window_tree_binding.h"
 #include "mojo/common/common_type_converters.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/converters/input_events/input_events_type_converters.h"
+#include "mojo/shell/public/interfaces/connector.mojom.h"
 
 namespace mus {
 namespace ws {
 namespace {
 
 base::TimeDelta GetDefaultAckTimerDelay() {
 #if defined(NDEBUG)
   return base::TimeDelta::FromMilliseconds(100);
 #else
   return base::TimeDelta::FromMilliseconds(1000);
@@ skipping 147 matching lines @@
   }
   return nullptr;
 }
 
 WindowManagerState* Display::GetFirstWindowManagerState() {
   return window_manager_state_map_.empty()
              ? nullptr
              : window_manager_state_map_.begin()->second.get();
 }
 
-WindowManagerState* Display::GetWindowManagerStateForUser(UserId user_id) {
+WindowManagerState* Display::GetWindowManagerStateForUser(
+    const UserId& user_id) {
   auto iter = window_manager_state_map_.find(user_id);
   return iter == window_manager_state_map_.end() ? nullptr : iter->second.get();
 }
 
 void Display::SetCapture(ServerWindow* window, bool in_nonclient_area) {
   ServerWindow* capture_window = event_dispatcher_.capture_window();
   if (capture_window == window)
     return;
   event_dispatcher_.SetCaptureWindow(window, in_nonclient_area);
 }
@@ skipping 95 matching lines @@
 void Display::InitWindowManagersIfNecessary() {
   if (!init_called_ || !root_)
     return;
 
   connection_manager_->OnDisplayAcceleratedWidgetAvailable(this);
   if (binding_) {
     scoped_ptr<WindowManagerState> wms_ptr(new WindowManagerState(this));
     WindowManagerState* wms = wms_ptr.get();
     // For this case we never create additional WindowManagerStates, so any
     // id works.
-    window_manager_state_map_[0u] = std::move(wms_ptr);
+    window_manager_state_map_[mojo::shell::mojom::kRootUserID] =
+        std::move(wms_ptr);
     wms->tree_ = binding_->CreateWindowTree(wms->root());
   } else {
     CreateWindowManagerStatesFromRegistry();
   }
 }
 
 void Display::OnEventAckTimeout() {
   // TODO(sad): Figure out what we should do.
   NOTIMPLEMENTED() << "Event ACK timed out.";
   OnEventAck(tree_awaiting_input_ack_);
@@ skipping 291 matching lines @@
   }
 
   DispatchInputEventToWindowImpl(target, in_nonclient_area, event);
 }
 
 void Display::OnWindowDestroyed(ServerWindow* window) {
   windows_needing_frame_destruction_.erase(window);
   window->RemoveObserver(this);
 }
 
-void Display::OnActiveUserIdChanged(UserId id) {
+void Display::OnActiveUserIdChanged(const UserId& id) {
   // TODO(sky): this likely needs to cancel any pending events and all that.
 }
 
-void Display::OnUserIdAdded(UserId id) {}
+void Display::OnUserIdAdded(const UserId& id) {}
 
-void Display::OnUserIdRemoved(UserId id) {
+void Display::OnUserIdRemoved(const UserId& id) {
   if (binding_)
     return;
 
   WindowManagerState* state = GetWindowManagerStateForUser(id);
   if (!state)
     return;
 
   // DestroyTree() calls back to OnWindowTreeConnectionError() and the
   // WindowManagerState is destroyed (and removed).
   connection_manager_->DestroyTree(state->tree());
   DCHECK_EQ(0u, window_manager_state_map_.count(id));
 }
 
 void Display::OnWindowManagerFactorySet(WindowManagerFactoryService* service) {
   CreateWindowManagerStateFromService(service);
 }
 
 }  // namespace ws
 }  // namespace mus