Fix the audio mute button broken issue.

ash/system/chromeos/audio/tray_audio.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/audio/tray_audio.h"
 
 #include <cmath>
 
 #include "ash/ash_constants.h"
 #include "ash/ash_switches.h"
@@ skipping 19 matching lines @@
 #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"
 
+using chromeos::CrasAudioHandler;
+
 namespace ash {
 namespace internal {
 
 namespace {
 const int kVolumeImageWidth = 25;
 const int kVolumeImageHeight = 25;
 const int kBarSeparatorWidth = 25;
 const int kBarSeparatorHeight = 30;
 const int kSliderRightPaddingToVolumeViewEdge = 17;
 const int kExtraPaddingBetweenBarAndMore = 10;
 
 const int kNoAudioDeviceIcon = -1;
 
 // 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() {
   if(ash::switches::UseNewAudioHandler()) {
-    return chromeos::CrasAudioHandler::Get()->IsOutputMuted();
+    return CrasAudioHandler::Get()->IsOutputMuted();
   } else {
     return Shell::GetInstance()->system_tray_delegate()->
         GetVolumeControlDelegate()->IsAudioMuted();
   }
 }
 
 float GetVolumeLevel() {
   if (ash::switches::UseNewAudioHandler()) {
-    return chromeos::CrasAudioHandler::Get()->GetOutputVolumePercent() / 100.0f;
+    return CrasAudioHandler::Get()->GetOutputVolumePercent() / 100.0f;
   } else {
     return Shell::GetInstance()->system_tray_delegate()->
         GetVolumeControlDelegate()->GetVolumeLevel();
   }
 }
 
 int GetAudioDeviceIconId(chromeos::AudioDeviceType type) {
   if (type == chromeos::AUDIO_TYPE_HEADPHONE)
     return IDR_AURA_UBER_TRAY_AUDIO_HEADPHONE;
   else if (type == chromeos::AUDIO_TYPE_USB)
@@ skipping 133 matching lines @@
 
   virtual ~VolumeView() {}
 
   void Update() {
     icon_->Update();
     slider_->Update();
     UpdateDeviceTypeAndMore();
     Layout();
   }
 
+  // Sets volume level on slider_, |percent| is ranged from [0.00] to [1.00].
   void SetVolumeLevel(float percent) {
+    // Slider's value is in finer granularity than audio volume level(0.01),
+    // there will be a small discrepancy between slider's value and volume level
+    // on audio side. To avoid the jittering in slider UI, do not set change
+    // slider value if the change is less than 1%.
+    if (std::abs(percent-slider_->value()) < 0.01)
+      return;
     // The change in volume will be reflected via accessibility system events,
     // so we prevent the UI event from being sent here.
     slider_->set_enable_accessibility_events(false);
     slider_->SetValue(percent);
     // It is possible that the volume was (un)muted, but the actual volume level
     // did not change. In that case, setting the value of the slider won't
     // trigger an update. So explicitly trigger an update.
     Update();
     slider_->set_enable_accessibility_events(true);
   }
 
  private:
   // Updates bar_, device_type_ icon, and more_ buttons.
   void UpdateDeviceTypeAndMore() {
     if (!ash::switches::ShowAudioDeviceMenu() || !is_default_view_) {
       more_->SetVisible(false);
       bar_->SetVisible(false);
       device_type_->SetVisible(false);
       return;
     }
 
-    chromeos::CrasAudioHandler* audio_handler =
-        chromeos::CrasAudioHandler::Get();
+    CrasAudioHandler* audio_handler = CrasAudioHandler::Get();
     bool show_more = audio_handler->has_alternative_output() ||
                      audio_handler->has_alternative_input();
     more_->SetVisible(show_more);
 
     // Show output device icon if necessary.
     chromeos::AudioDevice device;
     audio_handler->GetActiveOutputDevice(&device);
     int device_icon = GetAudioDeviceIconId(device.type);
     if (device_icon != kNoAudioDeviceIcon) {
       device_type_->SetVisible(true);
       device_type_->SetImage(
           ui::ResourceBundle::GetSharedInstance().GetImageNamed(
               device_icon).ToImageSkia());
       bar_->SetVisible(false);
     } else {
       device_type_->SetVisible(false);
       bar_->SetVisible(show_more);
     }
   }
 
+  void HandleVolumeUp(int volume) {
+    CrasAudioHandler* audio_handler = CrasAudioHandler::Get();
+    audio_handler->SetOutputVolumePercent(volume);
+    if (audio_handler->IsOutputMuted() &&
+        !audio_handler->IsOutputVolumeBelowDefaultMuteLvel())
+      audio_handler->SetOutputMute(false);
+  }
+
+  void HandleVolumeDown(int volume) {
+    CrasAudioHandler* audio_handler =  CrasAudioHandler::Get();
+    audio_handler->SetOutputVolumePercent(volume);
+    if (audio_handler->IsOutputVolumeBelowDefaultMuteLvel() &&
+        !audio_handler->IsOutputMuted()) {
+      audio_handler->SetOutputMute(true);
+    } else if (!audio_handler->IsOutputVolumeBelowDefaultMuteLvel() &&
+               audio_handler->IsOutputMuted()) {
+      audio_handler->SetOutputMute(false);
+    }
+  }
+
   // Overridden from views::View.
   virtual void Layout() OVERRIDE {
     views::View::Layout();
 
     if (!more_->visible()) {
       int w = width() - slider_->bounds().x() -
               kSliderRightPaddingToVolumeViewEdge;
       slider_->SetSize(gfx::Size(w, slider_->height()));
       return;
     }
@@ skipping 25 matching lines @@
         view_left_to_more->bounds().x() - kTrayPopupPaddingBetweenItems
         - slider_bounds.x());
     slider_->SetBoundsRect(slider_bounds);
   }
 
   // Overridden from views::ButtonListener.
   virtual void ButtonPressed(views::Button* sender,
                              const ui::Event& event) OVERRIDE {
     CHECK(sender == icon_);
     if (ash::switches::UseNewAudioHandler()) {
-      chromeos::CrasAudioHandler::Get()->SetOutputMute(!IsAudioMuted());
+      bool mute_on = !IsAudioMuted();
+      CrasAudioHandler::Get()->SetOutputMute(mute_on);
+      if (!mute_on)
+        CrasAudioHandler::Get()->AdjustOutputVolumeToAudibleLevel();
     } else {
       ash::Shell::GetInstance()->system_tray_delegate()->
           GetVolumeControlDelegate()->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) {
       if (ash::switches::UseNewAudioHandler()) {
-        chromeos::CrasAudioHandler::Get()->
-            SetOutputVolumePercent(value * 100.0f);
-      }
-      else {
+        int volume = value * 100.0f;
+        int old_volume = CrasAudioHandler::Get()->GetOutputVolumePercent();
+        // Do not call change audio volume if the difference is less than
+        // 1%, which is beyond cras audio api's granularity for output volume.
+        if (std::abs(volume - old_volume) < 1)
+          return;
+        if (volume > old_volume)
+          HandleVolumeUp(volume);
+        else
+          HandleVolumeDown(volume);
+      } else {
         ash::Shell::GetInstance()->system_tray_delegate()->
             GetVolumeControlDelegate()->SetVolumeLevel(value);
       }
     }
     icon_->Update();
   }
 
   // Overriden from ActinableView.
   virtual bool PerformAction(const ui::Event& event) OVERRIDE {
     if (!more_->visible())
@@ skipping 38 matching lines @@
   }
 
   void CreateHeaderEntry() {
     CreateSpecialRow(IDS_ASH_STATUS_TRAY_AUDIO, this);
   }
 
   void UpdateAudioDevices() {
     output_devices_.clear();
     input_devices_.clear();
     chromeos::AudioDeviceList devices;
-    chromeos::CrasAudioHandler::Get()->GetAudioDevices(&devices);
+    CrasAudioHandler::Get()->GetAudioDevices(&devices);
     for (size_t i = 0; i < devices.size(); ++i) {
       if (devices[i].is_input)
         input_devices_.push_back(devices[i]);
       else
         output_devices_.push_back(devices[i]);
     }
     UpdateScrollableList();
   }
 
   void UpdateScrollableList() {
@@ skipping 44 matching lines @@
   // Overridden from ViewClickListener.
   virtual void OnViewClicked(views::View* sender) OVERRIDE {
     if (sender == footer()->content()) {
       owner()->system_tray()->ShowDefaultView(BUBBLE_USE_EXISTING);
     } else {
       AudioDeviceMap::iterator iter = device_map_.find(sender);
       if (iter == device_map_.end())
         return;
       chromeos::AudioDevice& device = iter->second;
       if (device.is_input)
-        chromeos::CrasAudioHandler::Get()->SetActiveInputNode(device.id);
+        CrasAudioHandler::Get()->SetActiveInputNode(device.id);
       else
-        chromeos::CrasAudioHandler::Get()->SetActiveOutputNode(device.id);
+        CrasAudioHandler::Get()->SetActiveOutputNode(device.id);
     }
   }
 
   typedef std::map<views::View*, chromeos::AudioDevice> AudioDeviceMap;
 
   user::LoginStatus login_;
   chromeos::AudioDeviceList output_devices_;
   chromeos::AudioDeviceList input_devices_;
   AudioDeviceMap device_map_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioDetailedView);
 };
 
 }  // namespace tray
 
 TrayAudio::TrayAudio(SystemTray* system_tray)
     : TrayImageItem(system_tray, IDR_AURA_UBER_TRAY_VOLUME_MUTE),
       volume_view_(NULL),
       audio_detail_(NULL),
       pop_up_volume_view_(false) {
   if (ash::switches::UseNewAudioHandler())
-    chromeos::CrasAudioHandler::Get()->AddAudioObserver(this);
+    CrasAudioHandler::Get()->AddAudioObserver(this);
   else
     Shell::GetInstance()->system_tray_notifier()->AddAudioObserver(this);
 }
 
 TrayAudio::~TrayAudio() {
   if (ash::switches::UseNewAudioHandler()) {
-    if (chromeos::CrasAudioHandler::IsInitialized())
-      chromeos::CrasAudioHandler::Get()->RemoveAudioObserver(this);
+    if (CrasAudioHandler::IsInitialized())
+      CrasAudioHandler::Get()->RemoveAudioObserver(this);
   } else {
     Shell::GetInstance()->system_tray_notifier()->RemoveAudioObserver(this);
   }
 }
 
 bool TrayAudio::GetInitialVisibility() {
   return IsAudioMuted();
 }
 
 views::View* TrayAudio::CreateDefaultView(user::LoginStatus status) {
@@ skipping 111 matching lines @@
   if (audio_detail_)
     audio_detail_->Update();
   if (volume_view_) {
     volume_view_->SetVolumeLevel(GetVolumeLevel());
     volume_view_->Update();
   }
 }
 
 }  // namespace internal
 }  // namespace ash