Enable platform echo cancellation through the AudioRecord path.

content/renderer/media/media_stream_dependency_factory.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 "content/renderer/media/media_stream_dependency_factory.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 78 matching lines @@
                                 &already_set_value, NULL)) {
       constraints->AddMandatory(kDefaultAudioConstraints[i].key,
           kDefaultAudioConstraints[i].value, false);
     } else {
       DVLOG(1) << "Constraint " << kDefaultAudioConstraints[i].key
                << " already set to " << already_set_value;
     }
   }
 }
 
+void TransferConstraintToPlatformEffect(RTCMediaConstraints* constraints,
+                                        const char* key,
+                                        bool* platform_effect) {
+  bool value;
+  if (!webrtc::FindConstraint(constraints, key, &value, NULL) ||
+      value == false) {
+    // If the constraint does not exist, or is set to false, disable the
+    // corresponding platform effect.
+    *platform_effect = false;
+    DVLOG(1) << "Disabling platform effect: " << key;
+  } else {
+    if (*platform_effect) {
+      // If the constraint is set to true, and the corresponding platform effect
+      // is available, disable the constraint.
+      constraints->AddMandatory(key,
+          webrtc::MediaConstraintsInterface::kValueFalse, true);
+      DVLOG(1) << "Disabling constraint: " << key;
+    }
+  }
+}
+
+// Any true constraint with an available corresponding platform effect will be
+// set to false. Any false constraint will cause the corresponding platform
+// effect to be disabled.
+//
+// This currently only deals with AEC, but is prepared for expansion to other
+// platform effects.
+void TransferConstraintsToPlatformEffects(RTCMediaConstraints* constraints,
+    MediaStreamDevice::AudioDeviceParameters* params) {
+  TransferConstraintToPlatformEffect(constraints,
+      webrtc::MediaConstraintsInterface::kEchoCancellation,
+      &params->use_platform_aec);
+}
+
 class P2PPortAllocatorFactory : public webrtc::PortAllocatorFactoryInterface {
  public:
   P2PPortAllocatorFactory(
       P2PSocketDispatcher* socket_dispatcher,
       talk_base::NetworkManager* network_manager,
       talk_base::PacketSocketFactory* socket_factory,
       blink::WebFrame* web_frame)
       : socket_dispatcher_(socket_dispatcher),
         network_manager_(network_manager),
         socket_factory_(socket_factory),
@@ skipping 207 matching lines @@
         static_cast<MediaStreamSourceExtraData*>(source.extraData());
 
     // Check if the source has already been created. This happens when the same
     // source is used in multiple MediaStreams as a result of calling
     // getUserMedia.
     if (source_data->local_audio_source())
       continue;
 
     // TODO(xians): Create a new capturer for difference microphones when we
     // support multiple microphones. See issue crbug/262117 .
-    const StreamDeviceInfo device_info = source_data->device_info();
+    StreamDeviceInfo device_info = source_data->device_info();
+
+    RTCMediaConstraints platform_constraints = native_audio_constraints;
+    // This causes constraint settings to be transferred to their corresponding
+    // platform effects. For example, if a platform AEC is available, and the
+    // AEC constraint is set to true, we should leave the platform AEC
+    // enabled, and disable the software AEC by setting the constraint to false.
+    // Contrariwise, if the AEC constraint is set to false, we should disable
+    // the platform AEC even if available.
+    TransferConstraintsToPlatformEffects(&platform_constraints,
+                                         &device_info.device.input);
     scoped_refptr<WebRtcAudioCapturer> capturer(
         MaybeCreateAudioCapturer(render_view_id, device_info));
     if (!capturer.get()) {
       DLOG(WARNING) << "Failed to create the capturer for device "
                     << device_info.device.id;
       sources_created.Run(web_stream, false);
       // TODO(xians): Don't we need to check if source_observer is observing
       // something? If not, then it looks like we have a leak here.
       // OTOH, if it _is_ observing something, then the callback might
       // be called multiple times which is likely also a bug.
       return;
     }
     source_data->SetAudioCapturer(capturer);
 
     // Creates a LocalAudioSource object which holds audio options.
     // TODO(xians): The option should apply to the track instead of the source.
     source_data->SetLocalAudioSource(
-        CreateLocalAudioSource(&native_audio_constraints).get());
+        CreateLocalAudioSource(&platform_constraints).get());
     source_observer->AddSource(source_data->local_audio_source());
   }
 
   source_observer->StartObservering();
 }
 
 void MediaStreamDependencyFactory::CreateNativeLocalMediaStream(
     blink::WebMediaStream* web_stream) {
   DVLOG(1) << "MediaStreamDependencyFactory::CreateNativeLocalMediaStream()";
   if (!EnsurePeerConnectionFactory()) {
@@ skipping 548 matching lines @@
 
   if (!capturer->Initialize(
           render_view_id,
           static_cast<media::ChannelLayout>(
               device_info.device.input.channel_layout),
           device_info.device.input.sample_rate,
           device_info.device.input.frames_per_buffer,
           device_info.session_id,
           device_info.device.id,
           device_info.device.matched_output.sample_rate,
-          device_info.device.matched_output.frames_per_buffer)) {
+          device_info.device.matched_output.frames_per_buffer,
+          device_info.device.input.use_platform_aec)) {
     return NULL;
   }
 
   // Add the capturer to the WebRtcAudioDeviceImpl if it is a new capturer.
   if (is_new_capturer)
     GetWebRtcAudioDevice()->AddAudioCapturer(capturer);
 
   return capturer;
 }
 
@@ skipping 28 matching lines @@
 MediaStreamDependencyFactory::GetNativeMediaStreamTrack(
       const blink::WebMediaStreamTrack& track) {
   if (track.isNull())
     return NULL;
   MediaStreamTrackExtraData* extra_data =
       static_cast<MediaStreamTrackExtraData*>(track.extraData());
   return extra_data ? extra_data->track().get() : NULL;
 }
 
 }  // namespace content