Add SystemTrayObservers

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 "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/system/audio/audio_observer.h"
 #include "ash/system/bluetooth/bluetooth_observer.h"
 #include "ash/system/brightness/brightness_observer.h"
 #include "ash/system/chromeos/network/network_observer.h"
 #include "ash/system/date/clock_observer.h"
 #include "ash/system/drive/drive_observer.h"
 #include "ash/system/ime/ime_observer.h"
 #include "ash/system/power/power_status_observer.h"
 #include "ash/system/tray/system_tray.h"
 #include "ash/system/tray/system_tray_delegate.h"
+#include "ash/system/tray/system_tray_observers.h"
 #include "ash/system/tray_accessibility.h"
 #include "ash/system/tray_caps_lock.h"
 #include "ash/system/user/update_observer.h"
 #include "ash/system/user/user_observer.h"
 #include "ash/volume_control_delegate.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/chromeos/chromeos_version.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 138 matching lines @@
         network_icon_(ALLOW_THIS_IN_INITIALIZER_LIST(
                       new NetworkMenuIcon(this, NetworkMenuIcon::MENU_MODE))),
         network_icon_dark_(ALLOW_THIS_IN_INITIALIZER_LIST(
                       new NetworkMenuIcon(this, NetworkMenuIcon::MENU_MODE))),
         network_menu_(ALLOW_THIS_IN_INITIALIZER_LIST(new NetworkMenu(this))),
         clock_type_(base::k24HourClock),
         search_key_mapped_to_(input_method::kSearchKey),
         screen_locked_(false),
         connected_network_state_(STATE_UNKNOWN),
         data_promo_notification_(new DataPromoNotification()),
-        volume_control_delegate_(ALLOW_THIS_IN_INITIALIZER_LIST(
-            new VolumeController)) {
+        volume_control_delegate_(new VolumeController()),
+        system_tray_observers_(new ash::SystemTrayObservers()) {
     // Register notifications on construction so that events such as
     // PROFILE_CREATED do not get missed if they happen before Initialize().
     registrar_.Add(this,
                    chrome::NOTIFICATION_UPGRADE_RECOMMENDED,
                    content::NotificationService::AllSources());
     registrar_.Add(this,
                    chrome::NOTIFICATION_LOGIN_USER_IMAGE_CHANGED,
                    content::NotificationService::AllSources());
     if (GetUserLoginStatus() == ash::user::LOGGED_IN_NONE) {
       registrar_.Add(this,
@@ skipping 32 matching lines @@
                                 g_browser_process->local_state(), this);
 
     network_icon_->SetResourceColorTheme(NetworkMenuIcon::COLOR_LIGHT);
     network_icon_dark_->SetResourceColorTheme(NetworkMenuIcon::COLOR_DARK);
 
     bluetooth_adapter_ = device::BluetoothAdapterFactory::DefaultAdapter();
     bluetooth_adapter_->AddObserver(this);
   }
 
   virtual ~SystemTrayDelegate() {
+    // Clear observers first.
+    system_tray_observers_.reset();
+
     AudioHandler* audiohandler = AudioHandler::GetInstance();
     if (audiohandler)
       audiohandler->RemoveVolumeObserver(this);
     DBusThreadManager::Get()->GetSessionManagerClient()->RemoveObserver(this);
     DBusThreadManager::Get()->GetPowerManagerClient()->RemoveObserver(this);
     NetworkLibrary* crosnet = CrosLibrary::Get()->GetNetworkLibrary();
     if (crosnet) {
       crosnet->RemoveNetworkManagerObserver(this);
       crosnet->RemoveCellularDataPlanObserver(this);
     }
     input_method::InputMethodManager::GetInstance()->RemoveObserver(this);
     system::TimezoneSettings::GetInstance()->RemoveObserver(this);
     if (SystemKeyEventListener::GetInstance())
       SystemKeyEventListener::GetInstance()->RemoveCapsLockObserver(this);
     bluetooth_adapter_->RemoveObserver(this);
 
     // Stop observing gdata operations.
     DriveSystemService* system_service = FindDriveSystemService();
     if (system_service) {
       system_service->drive_service()->RemoveObserver(this);
     }
   }
 
+  virtual ash::SystemTrayObservers* GetSystemTrayObservers() OVERRIDE {
+    return system_tray_observers_.get();
+  }
+
   // Overridden from ash::SystemTrayDelegate:
   virtual bool GetTrayVisibilityOnStartup() OVERRIDE {
     // In case of OOBE / sign in screen tray will be shown later.
     return UserManager::Get()->IsUserLoggedIn();
   }
 
   virtual const string16 GetUserDisplayName() const OVERRIDE {
     return UserManager::Get()->GetLoggedInUser()->GetDisplayName();
   }
 
@@ skipping 354 matching lines @@
     chrome::ShowSettingsSubPage(GetAppropriateBrowser(),
                                 chrome::kBluetoothAddDeviceSubPage);
   }
 
   virtual void ToggleAirplaneMode() OVERRIDE {
     NetworkLibrary* crosnet = CrosLibrary::Get()->GetNetworkLibrary();
     crosnet->EnableOfflineMode(!crosnet->offline_mode());
   }
 
   virtual void ToggleWifi() OVERRIDE {
-    GetSystemTray()->network_observer()->OnWillToggleWifi();
+    FOR_EACH_OBSERVER(ash::NetworkObserver,
+                      system_tray_observers_->network_observers(),
+                      OnWillToggleWifi());
     network_menu_->ToggleWifi();
   }
 
   virtual void ToggleMobile() OVERRIDE {
     network_menu_->ToggleMobile();
   }
 
   virtual void ToggleBluetooth() OVERRIDE {
     bluetooth_adapter_->SetPowered(!bluetooth_adapter_->IsPowered(),
                                    base::Bind(&base::DoNothing),
@@ skipping 122 matching lines @@
     DriveSystemService* system_service = FindDriveSystemService();
     if (!system_service)
       return;
 
     system_service->drive_service()->AddObserver(this);
   }
 
   void UpdateClockType(PrefService* service) {
     clock_type_ = service->GetBoolean(prefs::kUse24HourClock) ?
         base::k24HourClock : base::k12HourClock;
-    ash::ClockObserver* observer = GetSystemTray()->clock_observer();
-    if (observer)
-      observer->OnDateFormatChanged();
+    FOR_EACH_OBSERVER(ash::ClockObserver,
+                      system_tray_observers_->clock_observers(),
+                      OnDateFormatChanged());
   }
 
   void NotifyRefreshClock() {
-    ash::ClockObserver* observer = GetSystemTray()->clock_observer();
-    if (observer)
-      observer->Refresh();
+    FOR_EACH_OBSERVER(ash::ClockObserver,
+                      system_tray_observers_->clock_observers(),
+                      Refresh());
   }
 
   void NotifyRefreshNetwork() {
-    ash::NetworkObserver* observer = GetSystemTray()->network_observer();
     chromeos::NetworkLibrary* crosnet =
         chromeos::CrosLibrary::Get()->GetNetworkLibrary();
-    if (observer) {
-      ash::NetworkIconInfo info;
-      info.image = network_icon_->GetIconAndText(&info.description);
-      info.tray_icon_visible = network_icon_->ShouldShowIconInTray();
-      observer->OnNetworkRefresh(info);
-    }
-
-    ash::NetworkObserver* vpn_observer = GetSystemTray()->vpn_observer();
-    if (vpn_observer) {
-      ash::NetworkIconInfo info;
-      info.image = network_icon_->GetIconAndText(&info.description);
-      info.tray_icon_visible = network_icon_->ShouldShowIconInTray();
-      vpn_observer->OnNetworkRefresh(info);
-    }
+    ash::NetworkIconInfo info;
+    info.image = network_icon_->GetIconAndText(&info.description);
+    info.tray_icon_visible = network_icon_->ShouldShowIconInTray();
+    FOR_EACH_OBSERVER(ash::NetworkObserver,
+                      system_tray_observers_->network_observers(),
+                      OnNetworkRefresh(info));
+    FOR_EACH_OBSERVER(ash::NetworkObserver,
+                      system_tray_observers_->vpn_observers(),
+                      OnNetworkRefresh(info));
 
     // Update Accessibility.
 
     std::string connected_network_path;
     ConnectionState connected_network_state(STATE_UNKNOWN);
     if (crosnet->connected_network()) {
       connected_network_path = crosnet->connected_network()->service_path();
       connected_network_state = crosnet->connected_network()->state();
     }
     if (accessibility::IsSpokenFeedbackEnabled()) {
@@ skipping 10 matching lines @@
 
       if (speak)
         AccessibilitySpeak(crosnet->connected_network());
     }
 
     connected_network_path_ = connected_network_path_;
     connected_network_state_ = connected_network_state;
   }
 
   void NotifyRefreshBluetooth() {
-    ash::BluetoothObserver* observer = GetSystemTray()->bluetooth_observer();
-    if (observer)
-      observer->OnBluetoothRefresh();
+    FOR_EACH_OBSERVER(ash::BluetoothObserver,
+                      system_tray_observers_->bluetooth_observers(),
+                      OnBluetoothRefresh());
   }
 
   void NotifyBluetoothDiscoveringChanged() {
-    ash::BluetoothObserver* observer = GetSystemTray()->bluetooth_observer();
-    if (observer)
-      observer->OnBluetoothDiscoveringChanged();
+    FOR_EACH_OBSERVER(ash::BluetoothObserver,
+                      system_tray_observers_->bluetooth_observers(),
+                      OnBluetoothDiscoveringChanged());
   }
 
   void NotifyRefreshIME(bool show_message) {
-    ash::IMEObserver* observer = GetSystemTray()->ime_observer();
-    if (observer)
-      observer->OnIMERefresh(show_message);
+    FOR_EACH_OBSERVER(ash::IMEObserver,
+                      system_tray_observers_->ime_observers(),
+                      OnIMERefresh(show_message));
   }
 
   void NotifyRefreshDrive(ash::DriveOperationStatusList& list) {
-    ash::DriveObserver* observer = GetSystemTray()->drive_observer();
-    if (observer)
-      observer->OnDriveRefresh(list);
+    FOR_EACH_OBSERVER(ash::DriveObserver,
+                      system_tray_observers_->drive_observers(),
+                      OnDriveRefresh(list));
   }
 
   void RefreshNetworkObserver(NetworkLibrary* crosnet) {
     const Network* network = crosnet->active_network();
     std::string new_path = network ? network->service_path() : std::string();
     if (active_network_path_ != new_path) {
       if (!active_network_path_.empty())
         crosnet->RemoveNetworkObserver(active_network_path_, this);
       if (!new_path.empty())
         crosnet->AddNetworkObserver(new_path, this);
@@ skipping 103 matching lines @@
           l10n_util::GetStringUTF16(
               IDS_STATUSBAR_NETWORK_DEVICE_CONNECTING));
     }
     added->insert(network);
     list->push_back(info);
   }
 
   // Overridden from AudioHandler::VolumeObserver.
   virtual void OnVolumeChanged() OVERRIDE {
     float level = AudioHandler::GetInstance()->GetVolumePercent() / 100.f;
-    GetSystemTray()->audio_observer()->OnVolumeChanged(level);
+    FOR_EACH_OBSERVER(ash::AudioObserver,
+                      system_tray_observers_->audio_observers(),
+                      OnVolumeChanged(level));
   }
 
   // Overridden from AudioHandler::VolumeObserver.
   virtual void OnMuteToggled() OVERRIDE {
-    GetSystemTray()->audio_observer()->OnMuteToggled();
+    FOR_EACH_OBSERVER(ash::AudioObserver,
+                      system_tray_observers_->audio_observers(),
+                      OnMuteToggled());
   }
 
   // Overridden from PowerManagerClient::Observer.
   virtual void BrightnessChanged(int level, bool user_initiated) OVERRIDE {
-    GetSystemTray()->brightness_observer()->
-        OnBrightnessChanged(static_cast<double>(level), user_initiated);
+    FOR_EACH_OBSERVER(
+        ash::BrightnessObserver,
+        system_tray_observers_->brightness_observers(),
+        OnBrightnessChanged(static_cast<double>(level), user_initiated));
   }
 
   virtual void PowerChanged(const PowerSupplyStatus& power_status) OVERRIDE {
     power_supply_status_ = power_status;
     FOR_EACH_OBSERVER(ash::PowerStatusObserver,
-                      GetSystemTray()->power_status_observers(),
+                      system_tray_observers_->power_status_observers(),
                       OnPowerStatusChanged(power_status));
   }
 
   virtual void SystemResumed() OVERRIDE {
     NotifyRefreshClock();
   }
 
   // Overridden from SessionManagerClient::Observer.
   virtual void LockScreen() OVERRIDE {
     screen_locked_ = true;
@@ skipping 73 matching lines @@
 
           case UpgradeDetector::UPGRADE_ANNOYANCE_ELEVATED:
             severity = ash::UpdateObserver::UPDATE_LOW_GREEN;
             break;
 
           case UpgradeDetector::UPGRADE_ANNOYANCE_LOW:
           default:
             severity = ash::UpdateObserver::UPDATE_NORMAL;
             break;
         }
-        ash::UpdateObserver* observer = GetSystemTray()->update_observer();
-        if (observer)
-          observer->OnUpdateRecommended(severity);
+        FOR_EACH_OBSERVER(ash::UpdateObserver,
+                          system_tray_observers_->update_observers(),
+                          OnUpdateRecommended(severity));
         break;
       }
       case chrome::NOTIFICATION_LOGIN_USER_IMAGE_CHANGED: {
         // This notification is also sent on login screen when user avatar
         // is loaded from file.
         if (GetUserLoginStatus() != ash::user::LOGGED_IN_NONE) {
-          ash::UserObserver* observer = GetSystemTray()->user_observer();
-          if (observer)
-            observer->OnUserUpdate();
+          FOR_EACH_OBSERVER(ash::UserObserver,
+                            system_tray_observers_->user_observers(),
+                            OnUserUpdate());
         }
         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());
@@ skipping 14 matching lines @@
   }
 
   virtual void OnPreferenceChanged(PrefServiceBase* service,
                                    const std::string& pref) OVERRIDE {
     if (pref == prefs::kUse24HourClock) {
       UpdateClockType(static_cast<PrefService*>(service));
     } else if (pref == prefs::kLanguageRemapSearchKeyTo) {
       search_key_mapped_to_ =
           service->GetInteger(prefs::kLanguageRemapSearchKeyTo);
     } else if (pref == prefs::kSpokenFeedbackEnabled) {
-      ash::AccessibilityObserver* observer =
-          GetSystemTray()->accessibility_observer();
-      if (observer) {
-        observer->OnAccessibilityModeChanged(
-            service->GetBoolean(prefs::kSpokenFeedbackEnabled));
-      }
+      FOR_EACH_OBSERVER(
+          ash::AccessibilityObserver,
+          system_tray_observers_->accessibility_observers(),
+          OnAccessibilityModeChanged(
+              service->GetBoolean(prefs::kSpokenFeedbackEnabled)));
     } else {
       NOTREACHED();
     }
   }
 
   // Overridden from InputMethodManager::Observer.
   virtual void InputMethodChanged(
       input_method::InputMethodManager* manager, bool show_message) OVERRIDE {
     NotifyRefreshIME(show_message);
   }
@@ skipping 90 matching lines @@
     NotifyRefreshBluetooth();
   }
 
   // Overridden from SystemKeyEventListener::CapsLockObserver.
   virtual void OnCapsLockChange(bool enabled) OVERRIDE {
     bool search_mapped_to_caps_lock = false;
     if (!base::chromeos::IsRunningOnChromeOS() ||
         search_key_mapped_to_ == input_method::kCapsLockKey)
       search_mapped_to_caps_lock = true;
 
-    ash::CapsLockObserver* observer = GetSystemTray()->caps_lock_observer();
-    if (observer)
-      observer->OnCapsLockChanged(enabled, search_mapped_to_caps_lock);
+    FOR_EACH_OBSERVER(ash::CapsLockObserver,
+                      system_tray_observers_->caps_lock_observers(),
+                      OnCapsLockChanged(enabled, search_mapped_to_caps_lock));
   }
 
   // Overridden from ash::NetworkTrayDelegate
   virtual void NotificationLinkClicked(size_t index) OVERRIDE {
     // If we have deal info URL defined that means that there're
     // 2 links in bubble. Let the user close it manually then thus giving
     // ability to navigate to second link.
     // mobile_data_bubble_ will be set to NULL in BubbleClosing callback.
     std::string deal_info_url = data_promo_notification_->deal_info_url();
     std::string deal_topup_url = data_promo_notification_->deal_topup_url();
@@ skipping 42 matching lines @@
   std::string last_connection_string_;
 
   scoped_refptr<device::BluetoothAdapter> bluetooth_adapter_;
 
   BooleanPrefMember accessibility_enabled_;
 
   scoped_ptr<DataPromoNotification> data_promo_notification_;
 
   scoped_ptr<ash::VolumeControlDelegate> volume_control_delegate_;
 
+  scoped_ptr<ash::SystemTrayObservers> system_tray_observers_;
+
   DISALLOW_COPY_AND_ASSIGN(SystemTrayDelegate);
 };
 
 }  // namespace
 
 ash::SystemTrayDelegate* CreateSystemTrayDelegate() {
   return new chromeos::SystemTrayDelegate();
 }
 
 }  // namespace chromeos