Media Capture Depth Stream Extensions API: videoKind settings and constraint.

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/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "content/child/child_process.h"
+#include "content/renderer/media/media_stream_constraints_util_video_source.h"
 #include "content/renderer/media/media_stream_video_track.h"
 #include "content/renderer/media/video_track_adapter.h"
 
 namespace content {
 
 namespace {
 
 const char* const kLegalVideoConstraints[] = {"width",
                                               "height",
                                               "aspectRatio",
                                               "frameRate",
                                               "facingMode",
                                               "deviceId",
                                               "groupId",
                                               "mediaStreamSource",
-                                              "googNoiseReduction"};
+                                              "googNoiseReduction",
+                                              "videoKind"};
 
 // Returns true if |constraint| has mandatory constraints.
 bool HasMandatoryConstraints(const blink::WebMediaConstraints& constraints) {
   return constraints.basic().hasMandatory();
 }
 
 // Retrieve the desired max width and height from |constraints|. If not set,
 // the |desired_width| and |desired_height| are set to
 // std::numeric_limits<int>::max();
 // If either max or exact width or height is set as a mandatory constraint,
@@ skipping 93 matching lines @@
       (constraints.width.hasMax() && constraints.width.max() <= 0) ||
       (constraints.width.hasExact() &&
        constraints.width.exact() > format->frame_size.width())) {
     *failing_constraint_name = constraints.width.name();
   } else if ((constraints.height.hasMin() &&
               constraints.height.min() > format->frame_size.height()) ||
              (constraints.height.hasMax() && constraints.height.max() <= 0) ||
              (constraints.height.hasExact() &&
               constraints.height.exact() > format->frame_size.height())) {
     *failing_constraint_name = constraints.height.name();
+  } else if (constraints.videoKind.hasExact() &&
+             !constraints.videoKind.matches(GetVideoKindForFormat(*format))) {
+    *failing_constraint_name = constraints.videoKind.name();
   } else if (!constraints.frameRate.matches(format->frame_rate)) {
     if (constraints.frameRate.hasMax()) {
       const double value = constraints.frameRate.max();
       // TODO(hta): Check if handling of max = 0.0 is relevant.
       // (old handling was to set rate to 1.0 if 0.0 was specified)
       if (constraints.frameRate.matches(value)) {
         format->frame_rate =
             (format->frame_rate > value) ? value : format->frame_rate;
         return true;
       }
@@ skipping 463 matching lines @@
       callback(callback) {
 }
 
 MediaStreamVideoSource::TrackDescriptor::TrackDescriptor(
     const TrackDescriptor& other) = default;
 
 MediaStreamVideoSource::TrackDescriptor::~TrackDescriptor() {
 }
 
 }  // namespace content