mus: Add UserActivityMonitor.

components/mus/ws/window_manager_state.h

 // Copyright 2016 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.
 
 #ifndef COMPONENTS_MUS_WS_WINDOW_MANAGER_STATE_H_
 #define COMPONENTS_MUS_WS_WINDOW_MANAGER_STATE_H_
 
 #include <stdint.h>
 
 #include <memory>
 
 #include "base/memory/weak_ptr.h"
 #include "base/timer/timer.h"
 #include "components/mus/public/interfaces/display.mojom.h"
 #include "components/mus/ws/event_dispatcher.h"
 #include "components/mus/ws/event_dispatcher_delegate.h"
 #include "components/mus/ws/user_id.h"
 #include "components/mus/ws/window_server.h"
 
 namespace mus {
 namespace ws {
 
 class DisplayManager;
+class UserActivityMonitor;
 class WindowTree;
 
 namespace test {
 class WindowManagerStateTestApi;
 }
 
 // Manages state specific to a WindowManager that is shared across displays.
 // WindowManagerState is owned by the WindowTree the window manager is
 // associated with.
 class WindowManagerState : public EventDispatcherDelegate {

[sky, 2016/06/27 15:54:26]

This class is intended to own state from the windowmanager. The
UserActivityManager maintains state from connections with the same user and not
necessarily from the windowmanager. The two should have different lifetimes. The
way you have things now there is no guarantee the windowmanagerstate has been
created at the time you try to use it
(WindowServer::GetUserActivityMonitorForUser).

UserIdTracker tracks the set of known users. One option is to make UserId a real
class that has members and owns a UserActivityMonitor.

[sadrul, 2016/06/27 15:57:01]

I had considered having MusApp::UserState own the UserActivityMonitor
(https://cs.chromium.org/chromium/src/components/mus/mus_app.cc?sq=package:chr...).
Would that work?

[sadrul, 2016/06/27 20:46:13]

I ended up moving the ownership into WindowServer instead. (Keeping it in
MusApp::UserState would be possible, but we would need to add extra interfaces
somewhere to notify the UserActivityMonitor when some activity happens).

  public:
   explicit WindowManagerState(WindowTree* window_tree);
   ~WindowManagerState() override;
 
   const UserId& user_id() const;
 
   WindowTree* window_tree() { return window_tree_; }
   const WindowTree* window_tree() const { return window_tree_; }
 
+  UserActivityMonitor* user_activity_monitor() {
+    return user_activity_monitor_.get();
+  }
+
   void OnWillDestroyTree(WindowTree* tree);
 
   void SetFrameDecorationValues(mojom::FrameDecorationValuesPtr values);
   const mojom::FrameDecorationValues& frame_decoration_values() const {
     return *frame_decoration_values_;
   }
   bool got_frame_decoration_values() const {
     return got_frame_decoration_values_;
   }
 
@@ skipping 106 matching lines @@
 
   // Set to true the first time SetFrameDecorationValues() is called.
   bool got_frame_decoration_values_ = false;
   mojom::FrameDecorationValuesPtr frame_decoration_values_;
 
   mojom::WindowTree* tree_awaiting_input_ack_ = nullptr;
   std::unique_ptr<ui::Event> event_awaiting_input_ack_;
   base::WeakPtr<Accelerator> post_target_accelerator_;
   std::queue<std::unique_ptr<QueuedEvent>> event_queue_;
   base::OneShotTimer event_ack_timer_;
+  std::unique_ptr<UserActivityMonitor> user_activity_monitor_;
 
   EventDispatcher event_dispatcher_;
 
   // PlatformDisplay that currently has capture.
   PlatformDisplay* platform_display_with_capture_ = nullptr;
 
   base::WeakPtrFactory<WindowManagerState> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowManagerState);
 };
 
 }  // namespace ws
 }  // namespace mus
 
 #endif  // COMPONENTS_MUS_WS_WINDOW_MANAGER_STATE_H_