cros: Clean up SessionStateDelegate refs in Chrome

chrome/browser/chromeos/accessibility/magnification_manager.cc

 // Copyright (c) 2012 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/chromeos/accessibility/magnification_manager.h"
 
 #include <limits>
 #include <memory>
 
 #include "ash/common/accessibility_types.h"
-#include "ash/common/session/session_state_observer.h"
 #include "ash/magnifier/magnification_controller.h"
 #include "ash/magnifier/partial_magnification_controller.h"
 #include "ash/shell.h"
 #include "base/macros.h"
 #include "base/memory/singleton.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/accessibility/accessibility_manager.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/pref_names.h"
 #include "components/prefs/pref_member.h"
 #include "components/prefs/pref_service.h"
+#include "components/user_manager/user_manager.h"
 #include "content/public/browser/focused_node_details.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 
-class AccountId;
-
 namespace chromeos {
 
 namespace {
 static MagnificationManager* g_magnification_manager = NULL;
 }
 
-class MagnificationManagerImpl : public MagnificationManager,
-                                 public content::NotificationObserver,
-                                 public ash::SessionStateObserver {
+class MagnificationManagerImpl
+    : public MagnificationManager,
+      public content::NotificationObserver,
+      public user_manager::UserManager::UserSessionStateObserver {
  public:
   MagnificationManagerImpl()
       : profile_(NULL),
         magnifier_enabled_pref_handler_(
             prefs::kAccessibilityScreenMagnifierEnabled),
         magnifier_type_pref_handler_(prefs::kAccessibilityScreenMagnifierType),
         magnifier_scale_pref_handler_(
             prefs::kAccessibilityScreenMagnifierScale),
         type_(ash::kDefaultMagnifierType),
         enabled_(false),
         keep_focus_centered_(false),
         observing_focus_change_in_page_(false) {
     registrar_.Add(this,
                    chrome::NOTIFICATION_LOGIN_OR_LOCK_WEBUI_VISIBLE,
                    content::NotificationService::AllSources());
     registrar_.Add(this,
                    chrome::NOTIFICATION_SESSION_STARTED,
                    content::NotificationService::AllSources());
     registrar_.Add(this,
                    chrome::NOTIFICATION_PROFILE_DESTROYED,
                    content::NotificationService::AllSources());
   }
 
   ~MagnificationManagerImpl() override {
     CHECK(this == g_magnification_manager);
+
+    session_state_observer_.reset();

[James Cook, 2017/02/27 21:20:28]

ditto

[xiyuan, 2017/02/27 22:16:22]

Removed, same as the one in AccessibilityManager

   }
 
   // MagnificationManager implimentation:
   bool IsMagnifierEnabled() const override { return enabled_; }
 
   ash::MagnifierType GetMagnifierType() const override { return type_; }
 
   void SetMagnifierEnabled(bool enabled) override {
     if (!profile_)
       return;
@@ skipping 23 matching lines @@
   double GetSavedScreenMagnifierScale() const override {
     if (!profile_)
       return std::numeric_limits<double>::min();
 
     return profile_->GetPrefs()->GetDouble(
         prefs::kAccessibilityScreenMagnifierScale);
   }
 
   void SetProfileForTest(Profile* profile) override { SetProfile(profile); }
 
-  // SessionStateObserver overrides:
-  void ActiveUserChanged(const AccountId& account_id) override {
+  // user_manager::UserManager::UserSessionStateObserver overrides:
+  void ActiveUserChanged(const user_manager::User* active_user) override {
     SetProfile(ProfileManager::GetActiveUserProfile());
   }
 
  private:
   void SetProfile(Profile* profile) {
     pref_change_registrar_.reset();
 
     if (profile) {
       // TODO(yoshiki): Move following code to PrefHandler.
       pref_change_registrar_.reset(new PrefChangeRegistrar);
@@ skipping 128 matching lines @@
         Profile* profile = ProfileManager::GetActiveUserProfile();
         if (ProfileHelper::IsSigninProfile(profile))
           SetProfile(profile);
         break;
       }
       case chrome::NOTIFICATION_SESSION_STARTED:
         // Update |profile_| when entering a session.
         SetProfile(ProfileManager::GetActiveUserProfile());
 
         // Add a session state observer to be able to monitor session changes.
-        if (!session_state_observer_.get() && ash::Shell::HasInstance())
+        if (!session_state_observer_.get())
           session_state_observer_.reset(
-              new ash::ScopedSessionStateObserver(this));
+              new user_manager::ScopedUserSessionStateObserver(this));
         break;
       case chrome::NOTIFICATION_PROFILE_DESTROYED: {
         // Update |profile_| when exiting a session or shutting down.
         Profile* profile = content::Source<Profile>(source).ptr();
         if (profile_ == profile)
           SetProfile(NULL);
         break;
       }
       case content::NOTIFICATION_FOCUS_CHANGED_IN_PAGE: {
         content::FocusedNodeDetails* node_details =
@@ skipping 13 matching lines @@
   AccessibilityManager::PrefHandler magnifier_type_pref_handler_;
   AccessibilityManager::PrefHandler magnifier_scale_pref_handler_;
 
   ash::MagnifierType type_;
   bool enabled_;
   bool keep_focus_centered_;
   bool observing_focus_change_in_page_;
 
   content::NotificationRegistrar registrar_;
   std::unique_ptr<PrefChangeRegistrar> pref_change_registrar_;
-  std::unique_ptr<ash::ScopedSessionStateObserver> session_state_observer_;
+  std::unique_ptr<user_manager::ScopedUserSessionStateObserver>
+      session_state_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(MagnificationManagerImpl);
 };
 
 // static
 void MagnificationManager::Initialize() {
   CHECK(g_magnification_manager == NULL);
   g_magnification_manager = new MagnificationManagerImpl();
 }
 
 // static
 void MagnificationManager::Shutdown() {
   CHECK(g_magnification_manager);
   delete g_magnification_manager;
   g_magnification_manager = NULL;
 }
 
 // static
 MagnificationManager* MagnificationManager::Get() {
   return g_magnification_manager;
 }
 
 }  // namespace chromeos