mash: Move SystemTrayDelegate ownership to WmShell

ash/system/chromeos/bluetooth/tray_bluetooth.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 "ash/system/chromeos/bluetooth/tray_bluetooth.h"
 
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/system/tray/system_tray_delegate.h"
 #include "ash/common/system/tray/tray_constants.h"
+#include "ash/common/wm_shell.h"
 #include "ash/shell.h"
 #include "ash/system/tray/fixed_sized_scroll_view.h"
 #include "ash/system/tray/hover_highlight_view.h"
 #include "ash/system/tray/system_tray.h"
 #include "ash/system/tray/system_tray_notifier.h"
 #include "ash/system/tray/throbber_view.h"
 #include "ash/system/tray/tray_details_view.h"
 #include "ash/system/tray/tray_item_more.h"
 #include "ash/system/tray/tray_popup_header_button.h"
 #include "grit/ash_resources.h"
@@ skipping 48 matching lines @@
       : TrayItemMore(owner, show_more) {
     ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance();
     SetImage(bundle.GetImageNamed(IDR_AURA_UBER_TRAY_BLUETOOTH).ToImageSkia());
     UpdateLabel();
   }
 
   ~BluetoothDefaultView() override {}
 
   void UpdateLabel() {
     ash::SystemTrayDelegate* delegate =
-        ash::Shell::GetInstance()->system_tray_delegate();
+        ash::WmShell::Get()->system_tray_delegate();
     if (delegate->GetBluetoothAvailable()) {
       ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
       const base::string16 label =
           rb.GetLocalizedString(delegate->GetBluetoothEnabled()
                                     ? IDS_ASH_STATUS_TRAY_BLUETOOTH_ENABLED
                                     : IDS_ASH_STATUS_TRAY_BLUETOOTH_DISABLED);
       SetLabel(label);
       SetAccessibleName(label);
       SetVisible(true);
     } else {
@@ skipping 35 matching lines @@
 
  private:
   void CreateItems() {
     CreateScrollableList();
     AppendSettingsEntries();
     AppendHeaderEntry();
   }
 
   void BluetoothStartDiscovering() {
     ash::SystemTrayDelegate* delegate =
-        ash::Shell::GetInstance()->system_tray_delegate();
+        ash::WmShell::Get()->system_tray_delegate();
     bool bluetooth_enabled = delegate->GetBluetoothEnabled();
     bool bluetooth_discovering = delegate->GetBluetoothDiscovering();
     if (bluetooth_discovering) {
       throbber_->Start();
       return;
     }
     throbber_->Stop();
     if (bluetooth_enabled) {
       delegate->BluetoothStartDiscovering();
     }
   }
 
   void BluetoothStopDiscovering() {
     ash::SystemTrayDelegate* delegate =
-        ash::Shell::GetInstance()->system_tray_delegate();
+        ash::WmShell::Get()->system_tray_delegate();
     if (delegate && delegate->GetBluetoothDiscovering()) {
       delegate->BluetoothStopDiscovering();
       throbber_->Stop();
     }
   }
 
   void UpdateBluetoothDeviceList() {
     std::set<std::string> new_connecting_devices;
     std::set<std::string> new_connected_devices;
     std::set<std::string> new_paired_not_connected_devices;
     std::set<std::string> new_discovered_not_paired_devices;
 
     BluetoothDeviceList list;
-    Shell::GetInstance()->system_tray_delegate()->GetAvailableBluetoothDevices(
-        &list);
+    WmShell::Get()->system_tray_delegate()->GetAvailableBluetoothDevices(&list);
     for (size_t i = 0; i < list.size(); ++i) {
       if (list[i].connecting) {
         list[i].display_name = l10n_util::GetStringFUTF16(
             IDS_ASH_STATUS_TRAY_BLUETOOTH_CONNECTING, list[i].display_name);
         new_connecting_devices.insert(list[i].address);
         UpdateBluetoothDeviceListHelper(&connecting_devices_, list[i]);
       } else if (list[i].connected && list[i].paired) {
         new_connected_devices.insert(list[i].address);
         UpdateBluetoothDeviceListHelper(&connected_devices_, list[i]);
       } else if (list[i].paired) {
@@ skipping 22 matching lines @@
     if (login_ == LoginStatus::LOCKED)
       return;
 
     throbber_ = new ThrobberView;
     throbber_->SetTooltipText(
         l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_BLUETOOTH_DISCOVERING));
     footer()->AddView(throbber_, false /* separator */);
 
     // Do not allow toggling bluetooth in the lock screen.
     ash::SystemTrayDelegate* delegate =
-        ash::Shell::GetInstance()->system_tray_delegate();
+        ash::WmShell::Get()->system_tray_delegate();
     toggle_bluetooth_ =
         new TrayPopupHeaderButton(this, IDR_AURA_UBER_TRAY_BLUETOOTH_ENABLED,
                                   IDR_AURA_UBER_TRAY_BLUETOOTH_DISABLED,
                                   IDR_AURA_UBER_TRAY_BLUETOOTH_ENABLED_HOVER,
                                   IDR_AURA_UBER_TRAY_BLUETOOTH_DISABLED_HOVER,
                                   IDS_ASH_STATUS_TRAY_BLUETOOTH);
     toggle_bluetooth_->SetToggled(!delegate->GetBluetoothEnabled());
     toggle_bluetooth_->SetTooltipText(
         l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_DISABLE_BLUETOOTH));
     toggle_bluetooth_->SetToggledTooltipText(
         l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_ENABLE_BLUETOOTH));
     toggle_bluetooth_->EnableCanvasFlippingForRTLUI(false);
     footer()->AddButton(toggle_bluetooth_);
   }
 
   void UpdateHeaderEntry() {
     if (toggle_bluetooth_) {
-      toggle_bluetooth_->SetToggled(!ash::Shell::GetInstance()
-                                         ->system_tray_delegate()
-                                         ->GetBluetoothEnabled());
+      toggle_bluetooth_->SetToggled(
+          !ash::WmShell::Get()->system_tray_delegate()->GetBluetoothEnabled());
     }
   }
 
   void UpdateDeviceScrollList() {
     device_map_.clear();
     scroll_content()->RemoveAllChildViews(true);
     enable_bluetooth_ = NULL;
 
     ash::SystemTrayDelegate* delegate =
-        ash::Shell::GetInstance()->system_tray_delegate();
+        ash::WmShell::Get()->system_tray_delegate();
     bool bluetooth_enabled = delegate->GetBluetoothEnabled();
     bool blueooth_available = delegate->GetBluetoothAvailable();
     if (blueooth_available && !bluetooth_enabled && toggle_bluetooth_) {
       enable_bluetooth_ = AddScrollListItem(
           l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_ENABLE_BLUETOOTH),
           false /* highlight */, false /* checked */, true /* enabled */);
     }
 
     AppendSameTypeDevicesToScrollList(connected_devices_, true, true,
                                       bluetooth_enabled);
@@ skipping 37 matching lines @@
     HoverHighlightView* container = new HoverHighlightView(this);
     views::Label* label =
         container->AddCheckableLabel(text, highlight, checked);
     label->SetEnabled(enabled);
     scroll_content()->AddChildView(container);
     return container;
   }
 
   // Add settings entries.
   void AppendSettingsEntries() {
-    if (!ash::Shell::GetInstance()
-             ->system_tray_delegate()
-             ->ShouldShowSettings()) {
+    if (!ash::WmShell::Get()->system_tray_delegate()->ShouldShowSettings()) {

[msw, 2016/06/10 18:48:20]

nit: remove curlies

[James Cook, 2016/06/10 20:20:30]

Done.

       return;
     }
 
     // Add bluetooth device requires a browser window, hide it for non logged in
     // user.
     bool userAddingRunning = ash::Shell::GetInstance()
                                  ->session_state_delegate()
                                  ->IsInSecondaryLoginScreen();
 
     if (login_ == LoginStatus::NOT_LOGGED_IN || login_ == LoginStatus::LOCKED ||
         userAddingRunning)
       return;
 
     ash::SystemTrayDelegate* delegate =
-        ash::Shell::GetInstance()->system_tray_delegate();
+        ash::WmShell::Get()->system_tray_delegate();
     ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
     HoverHighlightView* container = new HoverHighlightView(this);
     container->AddLabel(
         rb.GetLocalizedString(IDS_ASH_STATUS_TRAY_BLUETOOTH_MANAGE_DEVICES),
         gfx::ALIGN_LEFT, false /* highlight */);
     container->SetEnabled(delegate->GetBluetoothAvailable());
     AddChildView(container);
     manage_devices_ = container;
   }
 
@@ skipping 26 matching lines @@
       static_cast<HoverHighlightView*>(item_container)
           ->AddCheckableLabel(display_name, true /* highlight */, false);
       scroll_content()->SizeToPreferredSize();
       static_cast<views::View*>(scroller())->Layout();
     }
   }
 
   // Overridden from ViewClickListener.
   void OnViewClicked(views::View* sender) override {
     ash::SystemTrayDelegate* delegate =
-        ash::Shell::GetInstance()->system_tray_delegate();
+        ash::WmShell::Get()->system_tray_delegate();
     if (sender == footer()->content()) {
       TransitionToDefaultView();
     } else if (sender == manage_devices_) {
       delegate->ManageBluetoothDevices();
     } else if (sender == enable_bluetooth_) {
       Shell::GetInstance()->metrics()->RecordUserMetricsAction(
           delegate->GetBluetoothEnabled()
               ? ash::UMA_STATUS_AREA_BLUETOOTH_DISABLED
               : ash::UMA_STATUS_AREA_BLUETOOTH_ENABLED);
       delegate->ToggleBluetooth();
     } else {
       if (!delegate->GetBluetoothEnabled())
         return;
       std::map<views::View*, std::string>::iterator find;
       find = device_map_.find(sender);
       if (find == device_map_.end())
         return;
       const std::string device_id = find->second;
       if (FoundDevice(device_id, connecting_devices_, NULL))
         return;
       UpdateClickedDevice(device_id, sender);
       delegate->ConnectToBluetoothDevice(device_id);
     }
   }
 
   // Overridden from ButtonListener.
   void ButtonPressed(views::Button* sender, const ui::Event& event) override {
     ash::SystemTrayDelegate* delegate =
-        ash::Shell::GetInstance()->system_tray_delegate();
+        ash::WmShell::Get()->system_tray_delegate();
     if (sender == toggle_bluetooth_)
       delegate->ToggleBluetooth();
     else
       NOTREACHED();
   }
 
   LoginStatus login_;
 
   std::map<views::View*, std::string> device_map_;
   views::View* manage_devices_;
@@ skipping 24 matching lines @@
 }
 
 views::View* TrayBluetooth::CreateDefaultView(LoginStatus status) {
   CHECK(default_ == NULL);
   default_ =
       new tray::BluetoothDefaultView(this, status != LoginStatus::LOCKED);
   return default_;
 }
 
 views::View* TrayBluetooth::CreateDetailedView(LoginStatus status) {
-  if (!Shell::GetInstance()->system_tray_delegate()->GetBluetoothAvailable())
+  if (!WmShell::Get()->system_tray_delegate()->GetBluetoothAvailable())
     return NULL;
   Shell::GetInstance()->metrics()->RecordUserMetricsAction(
       ash::UMA_STATUS_AREA_DETAILED_BLUETOOTH_VIEW);
   CHECK(detailed_ == NULL);
   detailed_ = new tray::BluetoothDetailedView(this, status);
   detailed_->Update();
   return detailed_;
 }
 
 void TrayBluetooth::DestroyTrayView() {}
@@ skipping 15 matching lines @@
     detailed_->Update();
 }
 
 void TrayBluetooth::OnBluetoothDiscoveringChanged() {
   if (!detailed_)
     return;
   detailed_->Update();
 }
 
 }  // namespace ash