[chromcast] Still need to call StreamMixerAlsa::SetVolume, even when ALSA doesn't own the volume.

chromecast/media/cma/backend/alsa/volume_control.cc

 // Copyright 2017 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 "chromecast/public/volume_control.h"
 
 #include <algorithm>
 #include <cmath>
 #include <map>
 #include <memory>
@@ skipping 115 matching lines @@
   }
 
   float GetVolume(AudioContentType type) {
     base::AutoLock lock(volume_lock_);
     return volumes_[type];
   }
 
   void SetVolume(AudioContentType type, float level) {
     level = std::max(0.0f, std::min(level, 1.0f));
     thread_.task_runner()->PostTask(
-        FROM_HERE, base::Bind(&VolumeControlInternal::SetVolumeOnThread,
-                              base::Unretained(this), type, level));
+        FROM_HERE,
+        base::Bind(&VolumeControlInternal::SetVolumeOnThread,
+                   base::Unretained(this), type, level, false /* from_alsa */));
   }
 
   bool IsMuted(AudioContentType type) {
     base::AutoLock lock(volume_lock_);
     return muted_[type];
   }
 
   void SetMuted(AudioContentType type, bool muted) {
     thread_.task_runner()->PostTask(
-        FROM_HERE, base::Bind(&VolumeControlInternal::SetMutedOnThread,
-                              base::Unretained(this), type, muted));
+        FROM_HERE,
+        base::Bind(&VolumeControlInternal::SetMutedOnThread,
+                   base::Unretained(this), type, muted, false /* from_alsa */));
   }
 
   void SetOutputLimit(AudioContentType type, float limit) {
-    if (BUILDFLAG(ALSA_CONTROLS_VOLUME)) {
+    if (BUILDFLAG(ALSA_OWNS_VOLUME)) {
       return;
     }
     limit = std::max(0.0f, std::min(limit, 1.0f));
     StreamMixerAlsa::Get()->SetOutputLimit(
         type, DbFsToScale(VolumeControl::VolumeToDbFS(limit)));
   }
 
  private:
   void InitializeOnThread() {
     DCHECK(thread_.task_runner()->BelongsToCurrentThread());
     alsa_volume_control_ = base::MakeUnique<AlsaVolumeControl>(this);
 
     double dbfs;
     for (auto type : {AudioContentType::kMedia, AudioContentType::kAlarm,
                       AudioContentType::kCommunication}) {
       CHECK(stored_values_.GetDouble(ContentTypeToDbFSKey(type), &dbfs));
       volumes_[type] = VolumeControl::DbFSToVolume(dbfs);
-      if (BUILDFLAG(ALSA_CONTROLS_VOLUME)) {
-        // If ALSA controls volume, our internal mixer should not apply any
-        // scaling multiplier.
+      if (BUILDFLAG(ALSA_OWNS_VOLUME)) {
+        // If ALSA owns volume, our internal mixer should not apply any scaling
+        // multiplier.
         StreamMixerAlsa::Get()->SetVolume(type, 1.0f);
       } else {
         StreamMixerAlsa::Get()->SetVolume(type, DbFsToScale(dbfs));
       }
 
       // Note that mute state is not persisted across reboots.
       muted_[type] = false;
     }
 
-    if (BUILDFLAG(ALSA_CONTROLS_VOLUME)) {
-      // If ALSA controls the volume, then read the current volume and mute
-      // state from the ALSA mixer element(s).
+    if (BUILDFLAG(ALSA_OWNS_VOLUME)) {
+      // If ALSA owns the volume, then read the current volume and mute state
+      // from the ALSA mixer element(s).
       volumes_[AudioContentType::kMedia] = alsa_volume_control_->GetVolume();
       muted_[AudioContentType::kMedia] = alsa_volume_control_->IsMuted();
     } else {
       // Otherwise, make sure the ALSA mixer element correctly reflects the
       // current volume state.
       alsa_volume_control_->SetVolume(volumes_[AudioContentType::kMedia]);
       alsa_volume_control_->SetMuted(false);
     }
 
     initialize_complete_event_.Signal();
   }
 
-  void SetVolumeOnThread(AudioContentType type, float level) {
+  void SetVolumeOnThread(AudioContentType type, float level, bool from_alsa) {
     DCHECK(thread_.task_runner()->BelongsToCurrentThread());
+    DCHECK(!from_alsa || type == AudioContentType::kMedia);
     {
       base::AutoLock lock(volume_lock_);
+      if (from_alsa && alsa_volume_control_->VolumeThroughAlsa(
+                           volumes_[AudioContentType::kMedia]) == level) {
+        return;
+      }
       if (level == volumes_[type]) {
         return;
       }
       volumes_[type] = level;
     }
 
     float dbfs = VolumeControl::VolumeToDbFS(level);
-    if (!BUILDFLAG(ALSA_CONTROLS_VOLUME)) {
+    if (!BUILDFLAG(ALSA_OWNS_VOLUME)) {
       StreamMixerAlsa::Get()->SetVolume(type, DbFsToScale(dbfs));
     }
 
-    if (type == AudioContentType::kMedia) {
+    if (!from_alsa && type == AudioContentType::kMedia) {
       alsa_volume_control_->SetVolume(level);
     }
 
     {
       base::AutoLock lock(observer_lock_);
       for (VolumeObserver* observer : volume_observers_) {
         observer->OnVolumeChange(type, level);
       }
     }
 
     stored_values_.SetDouble(ContentTypeToDbFSKey(type), dbfs);
     SerializeJsonToFile(storage_path_, stored_values_);
   }
 
-  void SetMutedOnThread(AudioContentType type, bool muted) {
+  void SetMutedOnThread(AudioContentType type, bool muted, bool from_alsa) {
     DCHECK(thread_.task_runner()->BelongsToCurrentThread());
     {
       base::AutoLock lock(volume_lock_);
       if (muted == muted_[type]) {
         return;
       }
       muted_[type] = muted;
     }
 
-    if (!BUILDFLAG(ALSA_CONTROLS_VOLUME)) {
+    if (!BUILDFLAG(ALSA_OWNS_VOLUME)) {
       StreamMixerAlsa::Get()->SetMuted(type, muted);
     }
 
-    if (type == AudioContentType::kMedia) {
+    if (!from_alsa && type == AudioContentType::kMedia) {
       alsa_volume_control_->SetMuted(muted);
     }
 
     {
       base::AutoLock lock(observer_lock_);
       for (VolumeObserver* observer : volume_observers_) {
         observer->OnMuteChange(type, muted);
       }
     }
   }
 
   // AlsaVolumeControl::Delegate implementation:
   void OnAlsaVolumeOrMuteChange(float new_volume, bool new_mute) override {
     DCHECK(thread_.task_runner()->BelongsToCurrentThread());
-    bool volume_changed = false;
-    bool mute_changed = false;
-    {
-      base::AutoLock lock(volume_lock_);
-      if (alsa_volume_control_->VolumeThroughAlsa(
-              volumes_[AudioContentType::kMedia]) != new_volume) {
-        volume_changed = true;
-        volumes_[AudioContentType::kMedia] = new_volume;
-      }
-
-      if (muted_[AudioContentType::kMedia] != new_mute) {
-        mute_changed = true;
-        muted_[AudioContentType::kMedia] = new_mute;
-      }
-    }
-
-    if (!volume_changed && !mute_changed) {
-      return;
-    }
-
-    {
-      base::AutoLock lock(observer_lock_);
-      if (volume_changed) {
-        for (VolumeObserver* observer : volume_observers_) {
-          observer->OnVolumeChange(AudioContentType::kMedia, new_volume);
-        }
-      }
-      if (mute_changed) {
-        for (VolumeObserver* observer : volume_observers_) {
-          observer->OnMuteChange(AudioContentType::kMedia, new_mute);
-        }
-      }
-    }
-
-    if (volume_changed) {
-      float dbfs = VolumeControl::VolumeToDbFS(new_volume);
-      stored_values_.SetDouble(ContentTypeToDbFSKey(AudioContentType::kMedia),
-                               dbfs);
-      SerializeJsonToFile(storage_path_, stored_values_);
-    }
+    SetVolumeOnThread(AudioContentType::kMedia, new_volume,
+                      true /* from_alsa */);
+    SetMutedOnThread(AudioContentType::kMedia, new_mute, true /* from_alsa */);
   }
 
   base::FilePath storage_path_;
   base::DictionaryValue stored_values_;
 
   base::Lock volume_lock_;
   std::map<AudioContentType, float> volumes_;
   std::map<AudioContentType, bool> muted_;
 
   base::Lock observer_lock_;
@@ skipping 86 matching lines @@
 
       return kVolumeMap[i - 1].level +
              (db - kVolumeMap[i - 1].db) * y_diff / x_diff;
     }
   }
   return kVolumeMap[arraysize(kVolumeMap) - 1].level;
 }
 
 }  // namespace media
 }  // namespace chromecast