Final cleanup pass over audio device API

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"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
+#include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "chromeos/audio/audio_device.h"
 #include "chromeos/audio/cras_audio_handler.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace extensions {
 
 using api::audio::OutputDeviceInfo;
@@ skipping 47 matching lines @@
  public:
   AudioServiceImpl();
   ~AudioServiceImpl() override;
 
   // 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;
+  bool GetDevices(const api::audio::DeviceFilter& filter,
+                  DeviceInfoList* devices_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 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;
@@ skipping 11 matching lines @@
  private:
   void NotifyDeviceChanged();
   void NotifyLevelChanged(uint64_t id, int level);
   void NotifyMuteChanged(bool is_input, bool is_muted);
   void NotifyDevicesChanged();
 
   uint64_t GetIdFromStr(const std::string& id_str);
   bool GetAudioNodeIdList(const DeviceIdList& ids,
                           bool is_input,
                           chromeos::CrasAudioHandler::NodeIdList* node_ids);
+  AudioDeviceInfo ToAudioDeviceInfo(const chromeos::AudioDevice& device);
 
   // List of observers.
   base::ObserverList<AudioService::Observer> observer_list_;
 
   chromeos::CrasAudioHandler* cras_audio_handler_;
 
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate the weak pointers before any other members are destroyed.
   base::WeakPtrFactory<AudioServiceImpl> weak_ptr_factory_;
 
@@ skipping 53 matching lines @@
       info.is_active = devices[i].active;
       info.gain =
           cras_audio_handler_->GetInputGainPercentForDevice(devices[i].id);
       info.is_muted = cras_audio_handler_->IsInputMutedForDevice(devices[i].id);
       input_info_out->push_back(std::move(info));
     }
   }
   return true;
 }
 
+bool AudioServiceImpl::GetDevices(const api::audio::DeviceFilter& filter,
+                                  DeviceInfoList* device_info_list_out) {

[jennyz, 2017/02/02 01:10:44]

Please keep the argument name consistent: device_info_list_out vs devices_out

[tbarzic, 2017/02/02 01:24:41]

Done.

+  if (!cras_audio_handler_)
+    return false;
+
+  chromeos::AudioDeviceList devices;
+  cras_audio_handler_->GetAudioDevices(&devices);
+
+  bool accept_input =
+      !filter.stream_types ||
+      base::ContainsValue(*filter.stream_types, api::audio::STREAM_TYPE_INPUT);
+  bool accept_output =
+      !filter.stream_types ||
+      base::ContainsValue(*filter.stream_types, api::audio::STREAM_TYPE_OUTPUT);
+
+  for (const auto& device : devices) {
+    if (filter.is_active && *filter.is_active != device.active)
+      continue;
+    if (device.is_input && !accept_input)
+      continue;
+    if (!device.is_input && !accept_output)
+      continue;
+    device_info_list_out->push_back(ToAudioDeviceInfo(device));
+  }
+
+  return true;
+}
+
 void AudioServiceImpl::SetActiveDevices(const DeviceIdList& device_list) {
   DCHECK(cras_audio_handler_);
   if (!cras_audio_handler_)
     return;
 
   chromeos::CrasAudioHandler::NodeIdList id_list;
   for (const auto& id : device_list) {
     const chromeos::AudioDevice* device =
         cras_audio_handler_->GetDeviceFromId(GetIdFromStr(id));
     if (device)
@@ skipping 111 matching lines @@
         cras_audio_handler_->GetDeviceFromId(GetIdFromStr(device_id));
     if (!device)
       return false;
     if (device->is_input != is_input)
       return false;
     node_ids->push_back(device->id);
   }
   return true;
 }
 
+AudioDeviceInfo AudioServiceImpl::ToAudioDeviceInfo(
+    const chromeos::AudioDevice& device) {
+  AudioDeviceInfo info;
+  info.id = base::Uint64ToString(device.id);
+  info.stream_type = device.is_input
+                         ? extensions::api::audio::STREAM_TYPE_INPUT
+                         : extensions::api::audio::STREAM_TYPE_OUTPUT;
+  info.is_input = device.is_input;
+  info.device_type = GetAsAudioApiDeviceType(device.type);
+  info.display_name = device.display_name;
+  info.device_name = device.device_name;
+  info.is_active = device.active;
+  info.is_muted = device.is_input
+                      ? cras_audio_handler_->IsInputMutedForDevice(device.id)
+                      : cras_audio_handler_->IsOutputMutedForDevice(device.id);
+  info.level =
+      device.is_input
+          ? cras_audio_handler_->GetOutputVolumePercentForDevice(device.id)
+          : cras_audio_handler_->GetInputGainPercentForDevice(device.id);
+  info.stable_device_id.reset(
+      new std::string(base::Uint64ToString(device.stable_device_id)));
+
+  return info;
+}
+
 void AudioServiceImpl::OnOutputNodeVolumeChanged(uint64_t id, int volume) {
   NotifyLevelChanged(id, volume);
 }
 
 void AudioServiceImpl::OnOutputMuteChanged(bool mute_on, bool system_adjust) {
   NotifyMuteChanged(false, mute_on);
 }
 
 void AudioServiceImpl::OnInputNodeGainChanged(uint64_t id, int gain) {
   NotifyLevelChanged(id, gain);
@@ skipping 33 matching lines @@
   for (auto& observer : observer_list_)
     observer.OnMuteChanged(is_input, is_muted);
 
   // Notify DeviceChanged event for backward compatibility.
   // TODO(jennyz): remove this code when the old version of hotrod retires.
   NotifyDeviceChanged();
 }
 
 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 = GetAsAudioApiDeviceType(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 =
-        devices[i].is_input
-            ? cras_audio_handler_->GetOutputVolumePercentForDevice(
-                  devices[i].id)
-            : cras_audio_handler_->GetInputGainPercentForDevice(devices[i].id);
-    info.stable_device_id.reset(
-        new std::string(base::Uint64ToString(devices[i].stable_device_id)));
 
-    devices_info_list.push_back(std::move(info));
+  DeviceInfoList device_info_list;
+  for (const auto& device : devices) {
+    device_info_list.push_back(ToAudioDeviceInfo(device));
   }
 
   for (auto& observer : observer_list_)
-    observer.OnDevicesChanged(devices_info_list);
+    observer.OnDevicesChanged(device_info_list);
 
   // 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