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/logging.h"
 #include "base/strings/string_number_conversions.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/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";
 const char MediaStreamVideoSource::kMaxWidth[] = "maxWidth";
@@ skipping 173 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;
-}
-
 // 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);
-  if (mandatory)
-    return;
-
-  GetConstraintValue(constraints, false, MediaStreamVideoSource::kMaxWidth,
+  GetConstraintValue(constraints, MediaStreamVideoSource::kMaxWidth,
                      desired_width);
-  GetConstraintValue(constraints, false, MediaStreamVideoSource::kMaxHeight,
+  GetConstraintValue(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) {
@@ skipping 81 matching lines @@
   tracks_.push_back(track);
 
   requested_constraints_.push_back(
       RequestedConstraints(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);
+      GetManatoryConstraintValue(constraints, kMaxWidth, &max_requested_width);

[tommi (sloooow) - chröme, 2014/04/08 10:49:30]

typo (here and throughout)

[no longer working on chromium, 2014/04/11 08:56:30]

Done.

 
       int max_requested_height = 0;
-      GetConstraintValue(constraints, true, kMaxHeight, &max_requested_height);
+      GetManatoryConstraintValue(constraints, kMaxHeight,
+                                 &max_requested_height);
 
       state_ = RETRIEVING_CAPABILITIES;
       GetCurrentSupportedFormats(max_requested_width,
                                  max_requested_height);
 
       break;
     }
     case STARTING:
     case RETRIEVING_CAPABILITIES: {
       // The |callback| will be triggered once the source has started or
@@ skipping 182 matching lines @@
 MediaStreamVideoSource::RequestedConstraints::RequestedConstraints(
     const blink::WebMediaConstraints& constraints,
     const ConstraintsCallback& callback)
     : constraints(constraints), callback(callback) {
 }
 
 MediaStreamVideoSource::RequestedConstraints::~RequestedConstraints() {
 }
 
 }  // namespace content