Consolidate volume control code.

ash/system/audio/tray_volume.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/audio/tray_volume.h"
 
 #include <cmath>
 
+#include "ash/accelerators/accelerator_controller.h"
 #include "ash/shell.h"
-#include "ash/system/tray/system_tray_delegate.h"
 #include "ash/system/tray/tray_constants.h"
 #include "ash/system/tray/tray_views.h"
+#include "ash/volume_control_delegate.h"
 #include "base/utf_string_conversions.h"
 #include "grit/ash_strings.h"
 #include "grit/ui_resources.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkRect.h"
 #include "third_party/skia/include/effects/SkGradientShader.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/controls/image_view.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/controls/slider.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/views/view.h"
 
 namespace ash {
 namespace internal {
 
 namespace {
 const int kVolumeImageWidth = 25;
 const int kVolumeImageHeight = 25;
 
 // IDR_AURA_UBER_TRAY_VOLUME_LEVELS contains 5 images,
 // The one for mute is at the 0 index and the other
 // four are used for ascending volume levels.
 const int kVolumeLevels = 4;
+
+bool IsAudioMuted() {
+  ash::VolumeControlDelegate* delegate =
+      Shell::GetInstance()->accelerator_controller()->volume_control_delegate();
+  return delegate ? delegate->IsAudioMuted() : false;
 }
 
+float GetVolumeLevel() {
+  ash::VolumeControlDelegate* delegate =
+      Shell::GetInstance()->accelerator_controller()->volume_control_delegate();
+  DCHECK(delegate);
+  return delegate->GetVolumeLevel();
+}
+
+}  // namespace
+
 namespace tray {
 
 class VolumeButton : public views::ToggleImageButton {
  public:
   explicit VolumeButton(views::ButtonListener* listener)
       : views::ToggleImageButton(listener),
         image_index_(-1) {
     SetImageAlignment(ALIGN_CENTER, ALIGN_MIDDLE);
     image_ = ui::ResourceBundle::GetSharedInstance().GetImageNamed(
         IDR_AURA_UBER_TRAY_VOLUME_LEVELS);
     SetPreferredSize(gfx::Size(kTrayPopupItemHeight, kTrayPopupItemHeight));
     Update();
   }
 
   virtual ~VolumeButton() {}
 
   void Update() {
-    ash::SystemTrayDelegate* delegate =
-        ash::Shell::GetInstance()->tray_delegate();
-    float level = delegate->GetVolumeLevel();
-    int image_index = delegate->IsAudioMuted() ?
+    float level = GetVolumeLevel();
+    int image_index = IsAudioMuted() ?
         0 : (level == 1.0 ?
              kVolumeLevels :
              std::max(1, int(std::ceil(level * (kVolumeLevels - 1)))));
     if (image_index != image_index_) {
       gfx::Rect region(0, image_index * kVolumeImageHeight,
                        kVolumeImageWidth, kVolumeImageHeight);
       gfx::ImageSkia image_skia = gfx::ImageSkiaOperations::ExtractSubset(
           *(image_.ToImageSkia()), region);
       SetImage(views::CustomButton::BS_NORMAL, &image_skia);
       image_index_ = image_index;
@@ skipping 19 matching lines @@
  public:
   explicit MuteButton(views::ButtonListener* listener)
       : TrayBarButtonWithTitle(listener,
             IDS_ASH_STATUS_TRAY_VOLUME_MUTE,
             kTrayBarButtonWidth) {
     Update();
   }
   virtual ~MuteButton() {}
 
   void Update() {
-    ash::SystemTrayDelegate* delegate =
-        ash::Shell::GetInstance()->tray_delegate();
-    UpdateButton(delegate->IsAudioMuted());
+    UpdateButton(IsAudioMuted());
     SchedulePaint();
   }
 
   DISALLOW_COPY_AND_ASSIGN(MuteButton);
 };
 
 class VolumeSlider : public views::Slider {
  public:
   explicit VolumeSlider(views::SliderListener* listener)
       : views::Slider(listener, views::Slider::HORIZONTAL) {
     set_focus_border_color(kFocusBorderColor);
-    SetValue(ash::Shell::GetInstance()->tray_delegate()->GetVolumeLevel());
+    SetValue(GetVolumeLevel());
     SetAccessibleName(
             ui::ResourceBundle::GetSharedInstance().GetLocalizedString(
                 IDS_ASH_STATUS_TRAY_VOLUME));
     Update();
   }
   virtual ~VolumeSlider() {}
 
   void Update() {
-    UpdateState(!ash::Shell::GetInstance()->tray_delegate()->IsAudioMuted());
+    UpdateState(!IsAudioMuted());
   }
 
   DISALLOW_COPY_AND_ASSIGN(VolumeSlider);
 };
 
 class VolumeView : public views::View,
                    public views::ButtonListener,
                    public views::SliderListener {
  public:
   VolumeView() {
@@ skipping 34 matching lines @@
   // Overridden from views::View.
   virtual void OnBoundsChanged(const gfx::Rect& old_bounds) OVERRIDE {
     int w = width() - slider_->x();
     slider_->SetSize(gfx::Size(w, slider_->height()));
   }
 
   // Overridden from views::ButtonListener.
   virtual void ButtonPressed(views::Button* sender,
                              const views::Event& event) OVERRIDE {
     CHECK(sender == icon_ || sender == mute_);
-    ash::SystemTrayDelegate* delegate =
-        ash::Shell::GetInstance()->tray_delegate();
-    delegate->SetAudioMuted(!delegate->IsAudioMuted());
+    ash::VolumeControlDelegate* delegate =
+        ash::Shell::GetInstance()->accelerator_controller()
+          ->volume_control_delegate();
+    if (delegate)
+      delegate->SetAudioMuted(!IsAudioMuted());
   }
 
   // Overridden from views:SliderListener.
   virtual void SliderValueChanged(views::Slider* sender,
                                   float value,
                                   float old_value,
                                   views::SliderChangeReason reason) OVERRIDE {
     if (reason == views::VALUE_CHANGED_BY_USER) {
-      ash::SystemTrayDelegate* delegate =
-          ash::Shell::GetInstance()->tray_delegate();
+      ash::VolumeControlDelegate* delegate =
+          ash::Shell::GetInstance()->accelerator_controller()
+            ->volume_control_delegate();
+      DCHECK(delegate);
       delegate->SetVolumeLevel(value);
     }
     icon_->Update();
   }
 
   VolumeButton* icon_;
   MuteButton* mute_;
   VolumeSlider* slider_;
 
   DISALLOW_COPY_AND_ASSIGN(VolumeView);
 };
 
 }  // namespace tray
 
 TrayVolume::TrayVolume()
     : TrayImageItem(IDR_AURA_UBER_TRAY_VOLUME_MUTE),
       volume_view_(NULL),
       is_default_view_(false) {
 }
 
 TrayVolume::~TrayVolume() {
 }
 
 bool TrayVolume::GetInitialVisibility() {
-  ash::SystemTrayDelegate* delegate =
-      ash::Shell::GetInstance()->tray_delegate();
-  return delegate->IsAudioMuted();
+  return IsAudioMuted();
 }
 
 views::View* TrayVolume::CreateDefaultView(user::LoginStatus status) {
   volume_view_ = new tray::VolumeView;
   is_default_view_ = true;
   return volume_view_;
 }
 
 views::View* TrayVolume::CreateDetailedView(user::LoginStatus status) {
   volume_view_ = new tray::VolumeView;
   is_default_view_ = false;
   return volume_view_;
 }
 
 void TrayVolume::DestroyDefaultView() {
   if (is_default_view_)
     volume_view_ = NULL;
 }
 
 void TrayVolume::DestroyDetailedView() {
   if (!is_default_view_)
     volume_view_ = NULL;
 }
 
+void TrayVolume::UpdateAfterAshInit() {
+  // Update the tray view after ash init, since VolumeControlDelegate won't be
+  // created until after the shell and system tray has been initialized.
+  if (tray_view())
+    tray_view()->SetVisible(GetInitialVisibility());
+}
+
 void TrayVolume::OnVolumeChanged(float percent) {
   if (tray_view())
     tray_view()->SetVisible(GetInitialVisibility());
 
   if (volume_view_) {
-    if (ash::Shell::GetInstance()->tray_delegate()->IsAudioMuted())
+    if (IsAudioMuted())
       percent = 0.0;
     volume_view_->SetVolumeLevel(percent);
     SetDetailedViewCloseDelay(kTrayPopupAutoCloseDelayInSeconds);
     return;
   }
   PopupDetailedView(kTrayPopupAutoCloseDelayInSeconds, false);
 }
 
 void TrayVolume::OnMuteToggled() {
   if (tray_view())
       tray_view()->SetVisible(GetInitialVisibility());
 
   if (volume_view_)
     volume_view_->Update();
   else
     PopupDetailedView(kTrayPopupAutoCloseDelayInSeconds, false);
 }
 
 }  // namespace internal
 }  // namespace ash