Open Ash shell after creating Profile

chrome/browser/chromeos/system/ash_system_tray_delegate.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/system/ash_system_tray_delegate.h"
 
 #include <algorithm>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 220 matching lines @@
                            public input_method::InputMethodManager::Observer,
                            public system::TimezoneSettings::Observer,
                            public chromeos::SystemClockClient::Observer,
                            public device::BluetoothAdapter::Observer,
                            public SystemKeyEventListener::CapsLockObserver,
                            public ash::NetworkTrayDelegate,
                            public policy::CloudPolicyStore::Observer {
  public:
   SystemTrayDelegate()
       : ui_weak_ptr_factory_(
-            new base::WeakPtrFactory<SystemTrayDelegate>(this)),
+          new base::WeakPtrFactory<SystemTrayDelegate>(this)),
+        user_profile_(NULL),
         clock_type_(base::k24HourClock),
         search_key_mapped_to_(input_method::kSearchKey),
         screen_locked_(false),
         have_session_start_time_(false),
         have_session_length_limit_(false),
         data_promo_notification_(new DataPromoNotification()),
         cellular_activating_(false),
         cellular_out_of_credits_(false),
         volume_control_delegate_(new VolumeController()) {
     // Register notifications on construction so that events such as
     // PROFILE_CREATED do not get missed if they happen before Initialize().
-    registrar_.Add(this,
+    registrar_.reset(new content::NotificationRegistrar);
+    registrar_->Add(this,
                    chrome::NOTIFICATION_UPGRADE_RECOMMENDED,
                    content::NotificationService::AllSources());
-    registrar_.Add(this,
+    registrar_->Add(this,
                    chrome::NOTIFICATION_LOGIN_USER_IMAGE_CHANGED,
                    content::NotificationService::AllSources());
     if (GetUserLoginStatus() == ash::user::LOGGED_IN_NONE) {
-      registrar_.Add(this,
+      registrar_->Add(this,
                      chrome::NOTIFICATION_SESSION_STARTED,
                      content::NotificationService::AllSources());
     }
-    registrar_.Add(this,
+    registrar_->Add(this,
                    chrome::NOTIFICATION_PROFILE_CREATED,
                    content::NotificationService::AllSources());
-    registrar_.Add(this,
+    registrar_->Add(this,
+                   chrome::NOTIFICATION_PROFILE_DESTROYED,
+                   content::NotificationService::AllSources());
+    registrar_->Add(this,
                    chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
                    content::NotificationService::AllSources());
-    registrar_.Add(
+    registrar_->Add(
         this,
         chrome::NOTIFICATION_CROS_ACCESSIBILITY_TOGGLE_SCREEN_MAGNIFIER,
         content::NotificationService::AllSources());
-    registrar_.Add(
+    registrar_->Add(
         this,
         chrome::NOTIFICATION_CROS_ACCESSIBILITY_TOGGLE_SPOKEN_FEEDBACK,
         content::NotificationService::AllSources());
-    registrar_.Add(
+    registrar_->Add(
         this,
         chrome::NOTIFICATION_CROS_ACCESSIBILITY_TOGGLE_HIGH_CONTRAST_MODE,
         content::NotificationService::AllSources());
   }
 
   virtual void Initialize() OVERRIDE {
     if (!ash::switches::UseNewAudioHandler()) {
       AudioHandler::GetInstance()->AddVolumeObserver(this);
     }
     DBusThreadManager::Get()->GetPowerManagerClient()->AddObserver(this);
@@ skipping 19 matching lines @@
   virtual void Shutdown() OVERRIDE {
     data_promo_notification_.reset();
   }
 
   void InitializeOnAdapterReady(
       scoped_refptr<device::BluetoothAdapter> adapter) {
     bluetooth_adapter_ = adapter;
     CHECK(bluetooth_adapter_);
     bluetooth_adapter_->AddObserver(this);
 
-    local_state_registrar_.Init(g_browser_process->local_state());
+    local_state_registrar_.reset(new PrefChangeRegistrar);
+    local_state_registrar_->Init(g_browser_process->local_state());
 
     UpdateSessionStartTime();
     UpdateSessionLengthLimit();
 
-    local_state_registrar_.Add(
+    local_state_registrar_->Add(
         prefs::kSessionStartTime,
         base::Bind(&SystemTrayDelegate::UpdateSessionStartTime,
                    base::Unretained(this)));
-    local_state_registrar_.Add(
+    local_state_registrar_->Add(
         prefs::kSessionLengthLimit,
         base::Bind(&SystemTrayDelegate::UpdateSessionLengthLimit,
                    base::Unretained(this)));
 
     policy::BrowserPolicyConnector* policy_connector =
         g_browser_process->browser_policy_connector();
     policy::DeviceCloudPolicyManagerChromeOS* policy_manager =
         policy_connector->GetDeviceCloudPolicyManager();
     if (policy_manager)
       policy_manager->core()->store()->AddObserver(this);
     UpdateEnterpriseDomain();
   }
 
   virtual ~SystemTrayDelegate() {
+    // Unregister PrefChangeRegistrars.
+    local_state_registrar_.reset();
+    user_pref_registrar_.reset();
+
+    // Unregister content notifications befure destroying any components.
+    registrar_.reset();
+
     if (!ash::switches::UseNewAudioHandler() && AudioHandler::GetInstance()) {
       AudioHandler::GetInstance()->RemoveVolumeObserver(this);
     }
 
     DBusThreadManager::Get()->GetSessionManagerClient()->RemoveObserver(this);
     DBusThreadManager::Get()->GetPowerManagerClient()->RemoveObserver(this);
     DBusThreadManager::Get()->GetSystemClockClient()->RemoveObserver(this);
     NetworkLibrary* crosnet = CrosLibrary::Get()->GetNetworkLibrary();
     if (crosnet)
       crosnet->RemoveNetworkManagerObserver(this);
@@ skipping 543 matching lines @@
 
   // Returns the last active browser. If there is no such browser, creates a new
   // browser window with an empty tab and returns it.
   Browser* GetAppropriateBrowser() {
     return chrome::FindOrCreateTabbedBrowser(
         ProfileManager::GetDefaultProfileOrOffTheRecord(),
         chrome::HOST_DESKTOP_TYPE_ASH);
   }
 
   void SetProfile(Profile* profile) {
+    user_profile_ = profile;
     PrefService* prefs = profile->GetPrefs();
     user_pref_registrar_.reset(new PrefChangeRegistrar);
     user_pref_registrar_->Init(prefs);
     user_pref_registrar_->Add(
         prefs::kUse24HourClock,
         base::Bind(&SystemTrayDelegate::UpdateClockType,
                    base::Unretained(this)));
     user_pref_registrar_->Add(
         prefs::kLanguageRemapSearchKeyTo,
         base::Bind(&SystemTrayDelegate::OnLanguageRemapSearchKeyToChanged,
                    base::Unretained(this)));
     user_pref_registrar_->Add(
         prefs::kShowLogoutButtonInTray,
         base::Bind(&SystemTrayDelegate::UpdateShowLogoutButtonInTray,
                    base::Unretained(this)));
     user_pref_registrar_->Add(
         prefs::kShouldAlwaysShowAccessibilityMenu,
         base::Bind(&SystemTrayDelegate::OnAccessibilityModeChanged,
                    base::Unretained(this),
                    ash::A11Y_NOTIFICATION_NONE));
 
     UpdateClockType();
     UpdateShowLogoutButtonInTray();
     search_key_mapped_to_ =
         profile->GetPrefs()->GetInteger(prefs::kLanguageRemapSearchKeyTo);
   }
 
+  bool UnsetProfile(Profile* profile) {
+    if (profile != user_profile_)
+      return false;
+    user_pref_registrar_.reset();
+    return true;
+  }
+
   void ObserveGDataUpdates() {
     DriveIntegrationService* integration_service =
         FindDriveIntegrationService();
     if (integration_service)
       integration_service->job_list()->AddObserver(this);
   }
 
   void UpdateClockType() {
     clock_type_ =
         user_pref_registrar_->prefs()->GetBoolean(prefs::kUse24HourClock) ?
             base::k24HourClock : base::k12HourClock;
     GetSystemTrayNotifier()->NotifyDateFormatChanged();
   }
 
   void UpdateShowLogoutButtonInTray() {
     GetSystemTrayNotifier()->NotifyShowLoginButtonChanged(
         user_pref_registrar_->prefs()->GetBoolean(
             prefs::kShowLogoutButtonInTray));
   }
 
   void UpdateSessionStartTime() {
-    const PrefService* local_state = local_state_registrar_.prefs();
+    const PrefService* local_state = local_state_registrar_->prefs();
     if (local_state->HasPrefPath(prefs::kSessionStartTime)) {
       have_session_start_time_ = true;
       session_start_time_ = base::TimeTicks::FromInternalValue(
           local_state->GetInt64(prefs::kSessionStartTime));
     } else {
       have_session_start_time_ = false;
       session_start_time_ = base::TimeTicks();
     }
     GetSystemTrayNotifier()->NotifySessionStartTimeChanged();
   }
 
   void UpdateSessionLengthLimit() {
-    const PrefService* local_state = local_state_registrar_.prefs();
+    const PrefService* local_state = local_state_registrar_->prefs();
     if (local_state->HasPrefPath(prefs::kSessionLengthLimit)) {
       have_session_length_limit_ = true;
       session_length_limit_ = base::TimeDelta::FromMilliseconds(
           std::min(std::max(local_state->GetInteger(prefs::kSessionLengthLimit),
                             kSessionLengthLimitMinMs),
                    kSessionLengthLimitMaxMs));
     } else {
       have_session_length_limit_ = false;
       session_length_limit_ = base::TimeDelta();
     }
@@ skipping 88 matching lines @@
         }
         break;
       }
       case chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED: {
         // GData system service exists by the time if enabled.
         ObserveGDataUpdates();
         break;
       }
       case chrome::NOTIFICATION_PROFILE_CREATED: {
         SetProfile(content::Source<Profile>(source).ptr());
-        registrar_.Remove(this,
-                          chrome::NOTIFICATION_PROFILE_CREATED,
-                          content::NotificationService::AllSources());
+        registrar_->Remove(this,
+                           chrome::NOTIFICATION_PROFILE_CREATED,
+                           content::NotificationService::AllSources());
+        break;
+      }
+      case chrome::NOTIFICATION_PROFILE_DESTROYED: {
+        if (UnsetProfile(content::Source<Profile>(source).ptr())) {
+          registrar_->Remove(this,
+                             chrome::NOTIFICATION_PROFILE_DESTROYED,
+                             content::NotificationService::AllSources());
+        }
         break;
       }
       case chrome::NOTIFICATION_SESSION_STARTED: {
         ash::Shell::GetInstance()->UpdateAfterLoginStatusChange(
             GetUserLoginStatus());
         SetProfile(ProfileManager::GetDefaultProfile());
         break;
       }
       case chrome::NOTIFICATION_CROS_ACCESSIBILITY_TOGGLE_SPOKEN_FEEDBACK:
       case chrome::NOTIFICATION_CROS_ACCESSIBILITY_TOGGLE_HIGH_CONTRAST_MODE:
@@ skipping 188 matching lines @@
               ash::NetworkObserver::MESSAGE_DATA_PROMO,
               type,
               l10n_util::GetStringUTF16(IDS_NETWORK_CELLULAR_ACTIVATED_TITLE),
               l10n_util::GetStringFUTF16(IDS_NETWORK_CELLULAR_ACTIVATED,
                                          UTF8ToUTF16((cellular->name()))),
               std::vector<string16>());
     }
   }
 
   scoped_ptr<base::WeakPtrFactory<SystemTrayDelegate> > ui_weak_ptr_factory_;
-  content::NotificationRegistrar registrar_;
-  PrefChangeRegistrar local_state_registrar_;
+  scoped_ptr<content::NotificationRegistrar> registrar_;
+  scoped_ptr<PrefChangeRegistrar> local_state_registrar_;
   scoped_ptr<PrefChangeRegistrar> user_pref_registrar_;
+  Profile* user_profile_;
   std::string active_network_path_;
   base::HourClockType clock_type_;
   int search_key_mapped_to_;
   bool screen_locked_;
   bool have_session_start_time_;
   base::TimeTicks session_start_time_;
   bool have_session_length_limit_;
   base::TimeDelta session_length_limit_;
   std::string enterprise_domain_;
 
   scoped_refptr<device::BluetoothAdapter> bluetooth_adapter_;
 
   scoped_ptr<DataPromoNotification> data_promo_notification_;
   bool cellular_activating_;
   bool cellular_out_of_credits_;
 
   scoped_ptr<ash::VolumeControlDelegate> volume_control_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(SystemTrayDelegate);
 };
 
 }  // namespace
 
 ash::SystemTrayDelegate* CreateSystemTrayDelegate() {
   return new chromeos::SystemTrayDelegate();
 }
 
 }  // namespace chromeos