Add support for echoCancellation and deviceId to MediaStreamTrack.getSettings

content/browser/renderer_host/media/media_devices_dispatcher_host.cc

 // Copyright 2016 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 "content/browser/renderer_host/media/media_devices_dispatcher_host.h"
 
 #include <stddef.h>
 
 #include <utility>
 #include <vector>
 
 #include "base/bind_helpers.h"
+#include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/media/media_devices_util.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 #include "content/common/media/media_devices.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/media_device_id.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/common/media_stream_request.h"
 #include "media/audio/audio_system.h"
+#include "media/base/media_switches.h"
 #include "media/base/video_facing.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
 #include "url/origin.h"
 
 namespace content {
 
 namespace {
 
 // Resolutions used if the source doesn't support capability enumeration.
@@ skipping 456 matching lines @@
       base::Bind(&MediaDevicesDispatcherHost::GotAudioInputEnumeration,
                  weak_factory_.GetWeakPtr(), default_device_id));
 }
 
 void MediaDevicesDispatcherHost::GotAudioInputEnumeration(
     const std::string& default_device_id,
     const MediaDeviceEnumeration& enumeration) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK_GT(pending_audio_input_capabilities_requests_.size(), 0U);
   DCHECK(current_audio_input_capabilities_.empty());
+  DCHECK_EQ(num_pending_audio_input_parameters_, 0U);
   for (const auto& device_info : enumeration[MEDIA_DEVICE_TYPE_AUDIO_INPUT]) {
     ::mojom::AudioInputDeviceCapabilities capabilities(
-        device_info.device_id, media::AudioParameters());
+        device_info.device_id,
+        media::AudioParameters::UnavailableDeviceParams());
     if (device_info.device_id == default_device_id)
       current_audio_input_capabilities_.insert(
           current_audio_input_capabilities_.begin(), std::move(capabilities));
     else
       current_audio_input_capabilities_.push_back(std::move(capabilities));
   }
-  // No devices, no need to read audio parameters.
-  if (current_audio_input_capabilities_.empty()) {
+  // No devices or fake devices, no need to read audio parameters.
+  if (current_audio_input_capabilities_.empty() ||
+      base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kUseFakeDeviceForMediaStream)) {
     FinalizeGetAudioInputCapabilities();
     return;
   }
 
   num_pending_audio_input_parameters_ =
       current_audio_input_capabilities_.size();
   for (size_t i = 0; i < num_pending_audio_input_parameters_; ++i) {
     media_stream_manager_->audio_system()->GetInputStreamParameters(
         current_audio_input_capabilities_[i].device_id,
         base::Bind(&MediaDevicesDispatcherHost::GotAudioInputParameters,
                    weak_factory_.GetWeakPtr(), i));
   }
 }
 
 void MediaDevicesDispatcherHost::GotAudioInputParameters(
     size_t index,
     const media::AudioParameters& parameters) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK_GT(pending_audio_input_capabilities_requests_.size(), 0U);
   DCHECK_GT(current_audio_input_capabilities_.size(), index);
   DCHECK_GT(num_pending_audio_input_parameters_, 0U);
 
-  current_audio_input_capabilities_[index].parameters =
-      parameters.IsValid() ? parameters
-                           : media::AudioParameters::UnavailableDeviceParams();
+  if (parameters.IsValid())
+    current_audio_input_capabilities_[index].parameters = parameters;
+
+  DCHECK(current_audio_input_capabilities_[index].parameters.IsValid());
   if (--num_pending_audio_input_parameters_ == 0U)
     FinalizeGetAudioInputCapabilities();
 }
 
 void MediaDevicesDispatcherHost::FinalizeGetAudioInputCapabilities() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK_GT(pending_audio_input_capabilities_requests_.size(), 0U);
-  DCHECK_EQ(0U, num_pending_audio_input_parameters_);
+  DCHECK_EQ(num_pending_audio_input_parameters_, 0U);
 
   for (auto& request : pending_audio_input_capabilities_requests_) {
     std::move(request.client_callback)
         .Run(ToVectorAudioInputDeviceCapabilitiesPtr(
             current_audio_input_capabilities_, request.security_origin,
             device_id_salt_));
   }
 
   current_audio_input_capabilities_.clear();
   pending_audio_input_capabilities_requests_.clear();
 }
 
 }  // namespace content