Modify the volume visuals:

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 "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"
@@ skipping 88 matching lines @@
     SetLayoutManager(new views::BoxLayout(views::BoxLayout::kHorizontal,
           kTrayPopupPaddingHorizontal, 0, kTrayPopupPaddingBetweenItems));
 
     icon_ = new VolumeButton(this);
     AddChildView(icon_);
 
     ash::SystemTrayDelegate* delegate =
         ash::Shell::GetInstance()->tray_delegate();
     slider_ = new views::Slider(this, views::Slider::HORIZONTAL);
     slider_->set_focus_border_color(kFocusBorderColor);
-    slider_->SetValue(delegate->GetVolumeLevel());
+    slider_->SetValue(
+        delegate->IsAudioMuted() ? 0.0 :  delegate->GetVolumeLevel());
     slider_->SetAccessibleName(
         ui::ResourceBundle::GetSharedInstance().GetLocalizedString(
             IDS_ASH_STATUS_TRAY_VOLUME));
     AddChildView(slider_);
   }
 
   virtual ~VolumeView() {}
 
   void SetVolumeLevel(float percent) {
     // The change in volume will be reflected via accessibility system events,
@@ skipping 21 matching lines @@
     ash::SystemTrayDelegate* delegate =
         ash::Shell::GetInstance()->tray_delegate();
     delegate->SetAudioMuted(!delegate->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::Shell::GetInstance()->tray_delegate()->SetVolumeLevel(value);
+    if (reason == views::VALUE_CHANGED_BY_USER) {
+      ash::SystemTrayDelegate* delegate =
+          ash::Shell::GetInstance()->tray_delegate();
+      delegate->SetVolumeLevel(value);
+      if (delegate->IsAudioMuted() && value > 0.0)
+        delegate->SetAudioMuted(false);

[sadrul, 2012/05/19 02:10:54]

I don't think this is the right place for this change. Volume can be changed by
pressing the corresponding accelerator keys etc., and you will need to duplicate
this same code there too. Instead, the audio should be muted when volume-level
is set to zero in AudioHandler::SetVolumePercent so that we have this logic in
only place.

[Daniel Erat, 2012/05/19 05:38:34]

Sorry, I gave conflicting feedback in the review for
https://codereview.chromium.org/10411028/ (saying that a UX decision like this
one should be implemented in the UI rather than in the lower AudioHandler
layer).  My main concern was that enforcing the policy in AudioHandler removes
the flexibility to change the volume level that we'll restore to on unmute
without actually unmuting.

[Jun Mukai, 2012/05/21 17:05:38]

Still not sure which is better, but is there any real scenario where a user
wants to change the volume but not to unmute?  I couldn't imagine such case, so
sadrul's point sounds slightly more valid to me.

On 2012/05/19 05:38:34, Daniel Erat wrote:

[Jun Mukai, 2012/05/21 17:19:38]

Note that same thing was introduced to volume_controller:
http://src.chromium.org/viewvc/chrome/trunk/src/chrome/browser/ui/views/ash/v...

On 2012/05/21 17:05:38, Jun Mukai wrote:

+    }
     icon_->Update();
   }
 
   VolumeButton* icon_;
   views::Slider* 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() {
-  return ash::Shell::GetInstance()->tray_delegate()->IsAudioMuted();
+  ash::SystemTrayDelegate* delegate =
+      ash::Shell::GetInstance()->tray_delegate();
+  return delegate->GetVolumeLevel() == 0.0 || delegate->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::OnVolumeChanged(float percent) {
   if (tray_view())
     tray_view()->SetVisible(GetInitialVisibility());
 
   if (volume_view_) {
+    if (ash::Shell::GetInstance()->tray_delegate()->IsAudioMuted())
+      percent = 0.0;
     volume_view_->SetVolumeLevel(percent);
     SetDetailedViewCloseDelay(kTrayPopupAutoCloseDelayInSeconds);
     return;
   }
   PopupDetailedView(kTrayPopupAutoCloseDelayInSeconds, false);
 }
 
 }  // namespace internal
 }  // namespace ash