cros: Remove supervised user methods from SystemTrayDelegate

chrome/browser/ui/ash/session_controller_client.cc

 // 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.
 
 #include "chrome/browser/ui/ash/session_controller_client.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "ash/public/cpp/session_types.h"
 #include "ash/public/interfaces/constants.mojom.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/login/user_flow.h"
 #include "chrome/browser/chromeos/login/users/chrome_user_manager.h"
 #include "chrome/browser/chromeos/login/users/multi_profile_user_controller.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/browser/supervised_user/supervised_user_service.h"
+#include "chrome/browser/supervised_user/supervised_user_service_factory.h"
 #include "chrome/browser/ui/ash/multi_user/user_switch_util.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/theme_resources.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/session_manager_client.h"
 #include "components/prefs/pref_service.h"
 #include "components/session_manager/core/session_manager.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/common/service_manager_connection.h"
 #include "content/public/common/service_names.mojom.h"
@@ skipping 16 matching lines @@
   for (auto& session : SessionManager::Get()->sessions()) {
     if (session.user_account_id == account_id)
       return session.id;
   }
 
   return 0u;
 }
 
 // Creates a mojom::UserSession for the given user. Returns nullptr if there is
 // no user session started for the given user.
-ash::mojom::UserSessionPtr UserToUserSession(const User& user) {
+ash::mojom::UserSessionPtr UserToUserSession(const User& user,
+                                             Profile* login_profile) {

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

nit: We could use ProfileHelper to look up user profile from user?

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

Done.

   const uint32_t user_session_id = GetSessionId(user);
   if (user_session_id == 0u)
     return nullptr;
 
   ash::mojom::UserSessionPtr session = ash::mojom::UserSession::New();
   session->session_id = user_session_id;
   session->type = user.GetType();
   session->account_id = user.GetAccountId();
   session->display_name = base::UTF16ToUTF8(user.display_name());
   session->display_email = user.display_email();
 
   session->avatar = user.GetImage();
   if (session->avatar.isNull()) {
     session->avatar = *ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
         IDR_PROFILE_PICTURE_LOADING);
   }
 
+  if (user.IsSupervised() && login_profile) {
+    SupervisedUserService* service =
+        SupervisedUserServiceFactory::GetForProfile(login_profile);
+    session->custodian_email = service->GetCustodianEmailAddress();
+    session->second_custodian_email = service->GetSecondCustodianEmailAddress();
+  }
+
   chromeos::UserFlow* const user_flow =
       chromeos::ChromeUserManager::Get()->GetUserFlow(user.GetAccountId());
   session->should_enable_settings = user_flow->ShouldEnableSettings();
   session->should_show_notification_tray =
       user_flow->ShouldShowNotificationTray();
 
   return session;
 }
 
 void DoSwitchUser(const AccountId& account_id) {
   UserManager::Get()->SwitchActiveUser(account_id);
 }
 
 }  // namespace
 
 SessionControllerClient::SessionControllerClient() : binding_(this) {
   SessionManager::Get()->AddObserver(this);
   UserManager::Get()->AddSessionStateObserver(this);
   UserManager::Get()->AddObserver(this);
 
   registrar_.Add(this, chrome::NOTIFICATION_APP_TERMINATING,
                  content::NotificationService::AllSources());
-
-  ConnectToSessionControllerAndSetClient();
-  SendSessionInfoIfChanged();
-  // User sessions and their order will be sent via UserSessionStateObserver
-  // even for crash-n-restart.
+  registrar_.Add(this, chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
+                 content::NotificationService::AllSources());
 
   DCHECK(!g_instance);
   g_instance = this;
 }
 
 SessionControllerClient::~SessionControllerClient() {
   DCHECK_EQ(this, g_instance);
   g_instance = nullptr;
 
+  if (login_profile_) {
+    SupervisedUserServiceFactory::GetForProfile(login_profile_)
+        ->RemoveObserver(this);
+  }
   SessionManager::Get()->RemoveObserver(this);
   UserManager::Get()->RemoveObserver(this);
   UserManager::Get()->RemoveSessionStateObserver(this);
 }
 
+void SessionControllerClient::Init() {
+  ConnectToSessionController();
+  session_controller_->SetClient(binding_.CreateInterfacePtrAndBind());
+  SendSessionInfoIfChanged();
+  // User sessions and their order will be sent via UserSessionStateObserver
+  // even for crash-n-restart.
+}
+
 // static
 SessionControllerClient* SessionControllerClient::Get() {
   return g_instance;
 }
 
 void SessionControllerClient::StartLock(StartLockCallback callback) {
   session_controller_->StartLock(callback);
 }
 
 void SessionControllerClient::RunUnlockAnimation(
@@ skipping 140 matching lines @@
 
 // static
 void SessionControllerClient::FlushForTesting() {
   g_instance->session_controller_.FlushForTesting();
 }
 
 void SessionControllerClient::OnSessionStateChanged() {
   SendSessionInfoIfChanged();
 }
 
+void SessionControllerClient::OnCustodianInfoChanged() {
+  SendActiveUserSession();
+}
+
 void SessionControllerClient::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
-  DCHECK_EQ(chrome::NOTIFICATION_APP_TERMINATING, type);
-  session_controller_->NotifyChromeTerminating();
+  switch (type) {
+    case chrome::NOTIFICATION_APP_TERMINATING:
+      session_controller_->NotifyChromeTerminating();
+      break;
+    case chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED: {
+      Profile* profile = content::Details<Profile>(details).ptr();
+      OnLoginUserProfilePrepared(profile);
+      break;
+    }
+    default:
+      NOTREACHED() << "Unexpected notification " << type;
+      break;
+  }
 }
 
-void SessionControllerClient::ConnectToSessionControllerAndSetClient() {
+void SessionControllerClient::OnLoginUserProfilePrepared(Profile* profile) {
+  // NOTE: Some tests send the notification multiple times, so we can't
+  // DCHECK(!login_profile_);
+  login_profile_ = profile;
+
+  // Update the user session data with information from the profile.
+  SendActiveUserSession();
+
+  // Watch for changes to supervised user manager/custodians. Supervised users
+  // cannot use multiprofile so we don't need to worry about profile switching
+  // and adding/removing observers.
+  SupervisedUserServiceFactory::GetForProfile(login_profile_)
+      ->AddObserver(this);
+}
+
+void SessionControllerClient::ConnectToSessionController() {
+  // Tests may bind to their own SessionController.
+  if (session_controller_)
+    return;
+
   content::ServiceManagerConnection::GetForProcess()
       ->GetConnector()
       ->BindInterface(ash::mojom::kServiceName, &session_controller_);
-
-  // Set as |session_controller_|'s client.
-  session_controller_->SetClient(binding_.CreateInterfacePtrAndBind());
 }
 
 void SessionControllerClient::SendSessionInfoIfChanged() {
   SessionManager* const session_manager = SessionManager::Get();
 
   ash::mojom::SessionInfoPtr info = ash::mojom::SessionInfo::New();
   info->can_lock_screen = CanLockScreen();
   info->should_lock_screen_automatically = ShouldLockScreenAutomatically();
   info->add_user_session_policy = GetAddUserSessionPolicy();
   info->state = session_manager->session_state();
 
   if (info != last_sent_session_info_) {
     last_sent_session_info_ = info->Clone();
     session_controller_->SetSessionInfo(std::move(info));
   }
 }
 
 void SessionControllerClient::SendUserSession(const User& user) {
-  ash::mojom::UserSessionPtr user_session = UserToUserSession(user);
+  ash::mojom::UserSessionPtr user_session =
+      UserToUserSession(user, login_profile_);
 
   // Bail if the user has no session. Currently the only code path that hits
   // this condition is from OnUserImageChanged when user images are changed
   // on the login screen (e.g. policy change that adds a public session user,
   // or tests that create new users on the login screen).
   if (!user_session)
     return;
 
+  // TODO(jamescook): Only send if it changed. This will require an Equals()
+  // method for gfx::ImageSkia to allow mojom::UserSession comparison.
   session_controller_->UpdateUserSession(std::move(user_session));
 }
 
+void SessionControllerClient::SendActiveUserSession() {
+  User* active_user = UserManager::Get()->GetActiveUser();
+  DCHECK(active_user);
+  SendUserSession(*active_user);
+}
+
 void SessionControllerClient::SendUserSessionOrder() {
   UserManager* const user_manager = UserManager::Get();
 
   const UserList logged_in_users = user_manager->GetLoggedInUsers();
   std::vector<uint32_t> user_session_ids;
   for (auto* user : user_manager->GetLRULoggedInUsers()) {
     const uint32_t user_session_id = GetSessionId(*user);
     DCHECK_NE(0u, user_session_id);
     user_session_ids.push_back(user_session_id);
   }
 
   session_controller_->SetUserSessionOrder(user_session_ids);
 }