cros: Remove supervised user methods from SystemTrayDelegate

chrome/browser/ui/ash/session_controller_client.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 CHROME_BROWSER_UI_ASH_SESSION_CONTROLLER_CLIENT_H_
 #define CHROME_BROWSER_UI_ASH_SESSION_CONTROLLER_CLIENT_H_
 
 #include "ash/public/interfaces/session_controller.mojom.h"
 #include "base/callback_forward.h"
+#include "base/gtest_prod_util.h"
 #include "base/macros.h"
+#include "chrome/browser/supervised_user/supervised_user_service_observer.h"
 #include "components/session_manager/core/session_manager_observer.h"
 #include "components/user_manager/user_manager.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "mojo/public/cpp/bindings/binding.h"
 
+class Profile;
+
 namespace ash {
 enum class AddUserSessionPolicy;
 }
 
 namespace user_manager {
 class User;
 }
 
 // Updates session state etc to ash via SessionController interface and handles
 // session related calls from ash.
 // TODO(xiyuan): Update when UserSessionStateObserver is gone.
 class SessionControllerClient
     : public ash::mojom::SessionControllerClient,
       public user_manager::UserManager::UserSessionStateObserver,
       public user_manager::UserManager::Observer,
       public session_manager::SessionManagerObserver,
+      public SupervisedUserServiceObserver,
       public content::NotificationObserver {
  public:
   SessionControllerClient();
   ~SessionControllerClient() override;
 
+  void Init();
+
   static SessionControllerClient* Get();
 
   // Calls SessionController to start locking ash. |callback| will be invoked
   // to indicate whether the lock is successful. If |locked| is true, the post
   // lock animation is finished and ash is fully locked. Otherwise, the lock
   // is failed somehow.
   using StartLockCallback = base::Callback<void(bool locked)>;
   void StartLock(StartLockCallback callback);
 
   // Calls ash SessionController to run unlock animation.
   // |animation_finished_callback| will be invoked when the animation finishes.
   void RunUnlockAnimation(base::Closure animation_finished_callback);
 
   // ash::mojom::SessionControllerClient:
   void RequestLockScreen() override;
   void SwitchActiveUser(const AccountId& account_id) override;
   void CycleActiveUser(ash::CycleUserDirection direction) override;
 
   // user_manager::UserManager::UserSessionStateObserver:
   void ActiveUserChanged(const user_manager::User* active_user) override;
   void UserAddedToSession(const user_manager::User* added_user) override;
   void UserChangedChildStatus(user_manager::User* user) override;
 
   // user_manager::UserManager::Observer
   void OnUserImageChanged(const user_manager::User& user) override;
 
   // session_manager::SessionManagerObserver:
   void OnSessionStateChanged() override;
 
+  // SupervisedUserServiceObserver:
+  void OnCustodianInfoChanged() override;
+
   // content::NotificationObserver:
   void Observe(int type,
                const content::NotificationSource& source,
                const content::NotificationDetails& details) override;
 
   // TODO(xiyuan): Remove after SessionStateDelegateChromeOS is gone.
   static bool CanLockScreen();
   static bool ShouldLockScreenAutomatically();
   static ash::AddUserSessionPolicy GetAddUserSessionPolicy();
   static void DoLockScreen();
   static void DoSwitchActiveUser(const AccountId& account_id);
   static void DoCycleActiveUser(ash::CycleUserDirection direction);
 
   // Flushes the mojo pipe to ash.
   static void FlushForTesting();
 
  private:
-  // Connects or reconnects to the |session_controller_| interface and set
-  // this object as its client.
-  void ConnectToSessionControllerAndSetClient();
+  FRIEND_TEST_ALL_PREFIXES(SessionControllerClientTest, SupervisedUser);
+
+  // Called when the login profile is ready.
+  void OnLoginUserProfilePrepared(Profile* profile);
+
+  // Connects to the |session_controller_| interface.
+  void ConnectToSessionController();
 
   // Sends session info to ash.
   void SendSessionInfoIfChanged();
 
   // Sends the user session info.
   void SendUserSession(const user_manager::User& user);
 
+  // Sends an update for the active user session.
+  void SendActiveUserSession();
+
   // Sends the order of user sessions to ash.
   void SendUserSessionOrder();
 
   // Binds to the client interface.
   mojo::Binding<ash::mojom::SessionControllerClient> binding_;
 
   // SessionController interface in ash.
   ash::mojom::SessionControllerPtr session_controller_;
 
   // Whether the primary user session info is sent to ash.
   bool primary_user_session_sent_ = false;
 
-  // For observing NOTIFICATION_APP_TERMINATING.
+  // Profile for the logged-in user.
+  Profile* login_profile_ = nullptr;

[xiyuan, 2017/04/21 23:14:35]

login_profile_ -> user_profile_ to match other places in code.

[xiyuan, 2017/04/21 23:14:35]

How would this work with multi-profile? We might need a map<User*, Profile*>.

[James Cook, 2017/04/24 17:47:26]

How does this look?

Alternately, I could create a
SessionControllerClient::SupervisedUserServiceObserver object for each profile
as it is loaded. (I would have to do this to track which Profile* is being
observed, because OnCustodianInfoChanged() doesn't provide a Profile*.) This
would support multi-profile with multiple supervised users and would allow me to
call SendUserSession() on the correct user for custodian changes. However, we
don't actually support multiple supervised users in the product. WDYT?

[xiyuan, 2017/04/24 18:10:09]

Having a single |supervised_user_profile_| is okay since we don't support
multiple supervised users.

+
   content::NotificationRegistrar registrar_;
 
   ash::mojom::SessionInfoPtr last_sent_session_info_;
 
   DISALLOW_COPY_AND_ASSIGN(SessionControllerClient);
 };
 
 #endif  // CHROME_BROWSER_UI_ASH_SESSION_CONTROLLER_CLIENT_H_