Added a kEchoCancellation constraint to turn off the audio processing.

content/renderer/media/media_stream_video_source.cc

 // Copyright 2014 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_video_source.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "content/child/child_process.h"
+#include "content/renderer/media/media_stream_constraints_util.h"
 #include "content/renderer/media/media_stream_dependency_factory.h"
 #include "content/renderer/media/media_stream_video_track.h"
 #include "content/renderer/media/video_frame_deliverer.h"
 #include "content/renderer/media/webrtc/webrtc_video_capturer_adapter.h"
 
 namespace content {
 
 // Constraint keys. Specified by draft-alvestrand-constraints-resolution-00b
 const char MediaStreamVideoSource::kMinAspectRatio[] = "minAspectRatio";
 const char MediaStreamVideoSource::kMaxAspectRatio[] = "maxAspectRatio";
@@ skipping 13 matching lines @@
   MediaStreamVideoSource::kMinHeight,
   MediaStreamVideoSource::kMaxFrameRate,
   MediaStreamVideoSource::kMinFrameRate,
 };
 
 const int MediaStreamVideoSource::kDefaultWidth = 640;
 const int MediaStreamVideoSource::kDefaultHeight = 480;
 const int MediaStreamVideoSource::kDefaultFrameRate = 30;
 
 namespace {
-// Constraints keys for http://dev.w3.org/2011/webrtc/editor/getusermedia.html
-const char kSourceId[] = "sourceId";
 
 // Google-specific key prefix. Constraints with this prefix are ignored if they
 // are unknown.
 const char kGooglePrefix[] = "goog";
 
 // MediaStreamVideoSource supports cropping of video frames but only up to
 // kMaxCropFactor. Ie - if a constraint is set to maxHeight 360, an original
 // input frame height of max 360 * kMaxCropFactor pixels is accepted.
 const int kMaxCropFactor = 2;
 
@@ skipping 11 matching lines @@
 
   std::string constraint_name = constraint.m_name.utf8();
   std::string constraint_value = constraint.m_value.utf8();
 
   if (constraint_name.find(kGooglePrefix) == 0) {
     // These are actually options, not constraints, so they can be satisfied
     // regardless of the format.
     return true;
   }
 
-  if (constraint_name == kSourceId) {
+  if (constraint_name == MediaStreamSource::kSourceId) {
     // This is a constraint that doesn't affect the format.
     return true;
   }
 
   // Ignore Chrome specific Tab capture constraints.
   if (constraint_name == kMediaStreamSource ||
       constraint_name == kMediaStreamSourceId)
     return true;
 
   if (constraint_name == MediaStreamVideoSource::kMinAspectRatio ||
@@ skipping 107 matching lines @@
     FilterFormatsByConstraint(optional[i], false, &current_candidates);
     if (!current_candidates.empty()) {
       candidates = current_candidates;
     }
   }
 
   // We have done as good as we can to filter the supported resolutions.
   return candidates;
 }
 
-bool GetConstraintValue(const blink::WebMediaConstraints& constraints,
-                        bool mandatory, const blink::WebString& name,
-                        int* value) {
-  blink::WebString value_str;
-  bool ret = mandatory ?
-      constraints.getMandatoryConstraintValue(name, value_str) :
-      constraints.getOptionalConstraintValue(name, value_str);
-  if (ret)
-    base::StringToInt(value_str.utf8(), value);
-  return ret;
-}
-
 // Returns true if |constraint| has mandatory constraints.
 bool HasMandatoryConstraints(const blink::WebMediaConstraints& constraints) {
   blink::WebVector<blink::WebMediaConstraint> mandatory_constraints;
   constraints.getMandatoryConstraints(mandatory_constraints);
   return !mandatory_constraints.isEmpty();
 }
 
 // Retrieve the desired max width and height from |constraints|.
 void GetDesiredMaxWidthAndHeight(const blink::WebMediaConstraints& constraints,
                                  int* desired_width, int* desired_height) {
-  bool mandatory = GetConstraintValue(constraints, true,
-                                      MediaStreamVideoSource::kMaxWidth,
-                                      desired_width);
-  mandatory |= GetConstraintValue(constraints, true,
-                                  MediaStreamVideoSource::kMaxHeight,
-                                  desired_height);
+  bool mandatory = GetMandatoryConstraintValueAsInteger(
+      constraints, MediaStreamVideoSource::kMaxWidth, desired_width);
+  mandatory |= GetMandatoryConstraintValueAsInteger(
+      constraints, MediaStreamVideoSource::kMaxHeight, desired_height);
+  // Skip the optional constraints if any of the mandatory constraint is
+  // specified.
   if (mandatory)
     return;
 
-  GetConstraintValue(constraints, false, MediaStreamVideoSource::kMaxWidth,
-                     desired_width);
-  GetConstraintValue(constraints, false, MediaStreamVideoSource::kMaxHeight,
-                     desired_height);
+  GetOptionalConstraintValueAsInteger(constraints,
+                                      MediaStreamVideoSource::kMaxWidth,
+                                      desired_width);
+  GetOptionalConstraintValueAsInteger(constraints,
+                                      MediaStreamVideoSource::kMaxHeight,
+                                      desired_height);
 }
 
 const media::VideoCaptureFormat& GetBestFormatBasedOnArea(
     const media::VideoCaptureFormats& formats,
     int area) {
   media::VideoCaptureFormats::const_iterator it = formats.begin();
   media::VideoCaptureFormats::const_iterator best_it = formats.begin();
   int best_diff = std::numeric_limits<int>::max();
   for (; it != formats.end(); ++it) {
     int diff = abs(area - it->frame_size.width() * it->frame_size.height());
@@ skipping 156 matching lines @@
   tracks_.push_back(track);
 
   requested_constraints_.push_back(
       RequestedConstraints(track, frame_callback, constraints, callback));
 
   switch (state_) {
     case NEW: {
       // Tab capture and Screen capture needs the maximum requested height
       // and width to decide on the resolution.
       int max_requested_width = 0;
-      GetConstraintValue(constraints, true, kMaxWidth, &max_requested_width);
+      GetMandatoryConstraintValueAsInteger(constraints, kMaxWidth,
+                                           &max_requested_width);
 
       int max_requested_height = 0;
-      GetConstraintValue(constraints, true, kMaxHeight, &max_requested_height);
+      GetMandatoryConstraintValueAsInteger(constraints, kMaxHeight,
+                                           &max_requested_height);
 
       state_ = RETRIEVING_CAPABILITIES;
       GetCurrentSupportedFormats(
           max_requested_width,
           max_requested_height,
           base::Bind(&MediaStreamVideoSource::OnSupportedFormats,
                      weak_factory_.GetWeakPtr()));
 
       break;
     }
@@ skipping 172 matching lines @@
     : track(track),
       frame_callback(frame_callback),
       constraints(constraints),
       callback(callback) {
 }
 
 MediaStreamVideoSource::RequestedConstraints::~RequestedConstraints() {
 }
 
 }  // namespace content