chrome.audio API: treat mute as system wide property

extensions/browser/api/audio/audio_service_chromeos.cc

 // Copyright (c) 2013 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 "extensions/browser/api/audio/audio_service.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/callback.h"
@@ skipping 21 matching lines @@
   // Called by listeners to this service to add/remove themselves as observers.
   void AddObserver(AudioService::Observer* observer) override;
   void RemoveObserver(AudioService::Observer* observer) override;
 
   // Start to query audio device information.
   bool GetInfo(OutputInfo* output_info_out, InputInfo* input_info_out) override;
   void SetActiveDevices(const DeviceIdList& device_list) override;
   bool SetActiveDeviceLists(
       const std::unique_ptr<DeviceIdList>& input_devices,
       const std::unique_ptr<DeviceIdList>& output_devives) override;
-  bool SetDeviceProperties(const std::string& device_id,
-                           bool muted,
+  bool SetDeviceSoundLevel(const std::string& device_id,
                            int volume,
                            int gain) override;
+  bool SetMuteForDevice(const std::string& device_id, bool value) override;
+  bool SetMute(bool is_input, bool value) override;
+  bool GetMute(bool is_input, bool* value) override;
 
  protected:
   // chromeos::CrasAudioHandler::AudioObserver overrides.
   void OnOutputNodeVolumeChanged(uint64_t id, int volume) override;
   void OnInputNodeGainChanged(uint64_t id, int gain) override;
   void OnOutputMuteChanged(bool mute_on, bool system_adjust) override;
   void OnInputMuteChanged(bool mute_on) override;
   void OnAudioNodesChanged() override;
   void OnActiveOutputNodeChanged() override;
   void OnActiveInputNodeChanged() override;
@@ skipping 119 matching lines @@
     DCHECK(success);
   }
 
   if (input_ids.get()) {
     success = success && cras_audio_handler_->SetActiveInputNodes(input_nodes);
     DCHECK(success);
   }
   return success;
 }
 
-bool AudioServiceImpl::SetDeviceProperties(const std::string& device_id,
-                                           bool muted,
+bool AudioServiceImpl::SetDeviceSoundLevel(const std::string& device_id,
                                            int volume,
                                            int gain) {
   DCHECK(cras_audio_handler_);
   if (!cras_audio_handler_)
     return false;
 
   const chromeos::AudioDevice* device =
       cras_audio_handler_->GetDeviceFromId(GetIdFromStr(device_id));
   if (!device)
     return false;
 
-  cras_audio_handler_->SetMuteForDevice(device->id, muted);
-
   if (!device->is_input && volume != -1) {
     cras_audio_handler_->SetVolumeGainPercentForDevice(device->id, volume);
     return true;
   } else if (device->is_input && gain != -1) {
     cras_audio_handler_->SetVolumeGainPercentForDevice(device->id, gain);
     return true;
   }
 
   return false;
 }
 
+bool AudioServiceImpl::SetMuteForDevice(const std::string& device_id,
+                                        bool value) {
+  DCHECK(cras_audio_handler_);
+  if (!cras_audio_handler_)
+    return false;
+
+  const chromeos::AudioDevice* device =
+      cras_audio_handler_->GetDeviceFromId(GetIdFromStr(device_id));
+  if (!device)
+    return false;
+
+  cras_audio_handler_->SetMuteForDevice(device->id, value);
+  return true;
+}
+
+bool AudioServiceImpl::SetMute(bool is_input, bool value) {
+  DCHECK(cras_audio_handler_);
+  if (!cras_audio_handler_)
+    return false;
+
+  if (is_input)
+    cras_audio_handler_->SetInputMute(value);
+  else
+    cras_audio_handler_->SetOutputMute(value);
+  return true;
+}
+
+bool AudioServiceImpl::GetMute(bool is_input, bool* value) {
+  DCHECK(cras_audio_handler_);
+  if (!cras_audio_handler_)
+    return false;
+
+  if (is_input)
+    *value = cras_audio_handler_->IsInputMuted();
+  else
+    *value = cras_audio_handler_->IsOutputMuted();
+  return true;
+}
+
 uint64_t AudioServiceImpl::GetIdFromStr(const std::string& id_str) {
   uint64_t device_id;
   if (!base::StringToUint64(id_str, &device_id))
     return 0;
   else
     return device_id;
 }
 
 bool AudioServiceImpl::GetAudioNodeIdList(
     const DeviceIdList& ids,
@@ skipping 65 matching lines @@
 void AudioServiceImpl::NotifyDevicesChanged() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(cras_audio_handler_);
 
   DeviceInfoList devices_info_list;
   chromeos::AudioDeviceList devices;
   cras_audio_handler_->GetAudioDevices(&devices);
   for (size_t i = 0; i < devices.size(); ++i) {
     AudioDeviceInfo info;
     info.id = base::Uint64ToString(devices[i].id);
+    info.stream_type = devices[i].is_input
+                           ? extensions::api::audio::STREAM_TYPE_INPUT
+                           : extensions::api::audio::STREAM_TYPE_OUTPUT;
     info.is_input = devices[i].is_input;
     info.device_type = chromeos::AudioDevice::GetTypeString(devices[i].type);
     info.display_name = devices[i].display_name;
     info.device_name = devices[i].device_name;
     info.is_active = devices[i].active;
     info.is_muted =
         devices[i].is_input
             ? cras_audio_handler_->IsInputMutedForDevice(devices[i].id)
             : cras_audio_handler_->IsOutputMutedForDevice(devices[i].id);
     info.level =
@@ skipping 13 matching lines @@
   // Notify DeviceChanged event for backward compatibility.
   // TODO(jennyz): remove this code when the old version of hotrod retires.
   NotifyDeviceChanged();
 }
 
 AudioService* AudioService::CreateInstance() {
   return new AudioServiceImpl;
 }
 
 }  // namespace extensions