Count usage of mediastream audio and video constraints.

third_party/WebKit/Source/modules/mediastream/UserMediaRequest.cpp

 /*
  * Copyright (C) 2011 Ericsson AB. All rights reserved.
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 13 matching lines @@
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "modules/mediastream/UserMediaRequest.h"
 
+#include <type_traits>
+
 #include "bindings/core/v8/Dictionary.h"
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/SpaceSplitString.h"
 #include "core/frame/Deprecation.h"
 #include "core/frame/HostsUsingFeatures.h"
 #include "modules/mediastream/MediaConstraintsImpl.h"
 #include "modules/mediastream/MediaStream.h"
 #include "modules/mediastream/MediaStreamConstraints.h"
 #include "modules/mediastream/MediaTrackConstraints.h"
 #include "modules/mediastream/UserMediaController.h"
 #include "platform/mediastream/MediaStreamCenter.h"
 #include "platform/mediastream/MediaStreamDescriptor.h"
 
 namespace blink {
 
-static WebMediaConstraints ParseOptions(
-    ExecutionContext* context,
-    const BooleanOrMediaTrackConstraints& options,
-    MediaErrorState& error_state) {
+namespace {
+
+template <typename NumericConstraint>
+bool SetUsesNumericConstraint(
+    const WebMediaTrackConstraintSet& set,
+    NumericConstraint WebMediaTrackConstraintSet::*field) {
+  return (set.*field).HasExact() || (set.*field).HasIdeal() ||
+         (set.*field).HasMin() || (set.*field).HasMax();
+}
+
+template <typename DiscreteConstraint>
+bool SetUsesDiscreteConstraint(
+    const WebMediaTrackConstraintSet& set,
+    DiscreteConstraint WebMediaTrackConstraintSet::*field) {
+  return (set.*field).HasExact() || (set.*field).HasIdeal();
+}
+
+template <typename NumericConstraint>
+bool RequestUsesNumericConstraint(
+    const WebMediaConstraints& constraints,
+    NumericConstraint WebMediaTrackConstraintSet::*field) {
+  if (SetUsesNumericConstraint(constraints.Basic(), field))
+    return true;
+  for (const auto& advanced_set : constraints.Advanced()) {
+    if (SetUsesNumericConstraint(advanced_set, field))
+      return true;
+  }
+  return false;
+}
+
+template <typename DiscreteConstraint>
+bool RequestUsesDiscreteConstraint(
+    const WebMediaConstraints& constraints,
+    DiscreteConstraint WebMediaTrackConstraintSet::*field) {
+  static_assert(
+      std::is_same<decltype(field),
+                   StringConstraint WebMediaTrackConstraintSet::*>::value ||
+          std::is_same<decltype(field),
+                       BooleanConstraint WebMediaTrackConstraintSet::*>::value,
+      "Must use StringConstraint or BooleanConstraint");
+  if (SetUsesDiscreteConstraint(constraints.Basic(), field))
+    return true;
+  for (const auto& advanced_set : constraints.Advanced()) {
+    if (SetUsesDiscreteConstraint(advanced_set, field))
+      return true;
+  }
+  return false;
+}
+
+class FeatureCounter {
+  WTF_MAKE_NONCOPYABLE(FeatureCounter);
+
+ public:
+  FeatureCounter(ExecutionContext* context)
+      : context_(context), is_unconstrained_(true) {}
+  void Count(UseCounter::Feature feature) {
+    UseCounter::Count(context_, feature);
+    is_unconstrained_ = false;
+  }
+  bool IsUnconstrained() { return is_unconstrained_; }
+
+ private:
+  Persistent<ExecutionContext> context_;
+  bool is_unconstrained_;
+};
+
+void CountAudioConstraintUses(ExecutionContext* context,
+                              const WebMediaConstraints& constraints) {
+  FeatureCounter counter(context);
+  if (RequestUsesNumericConstraint(constraints,
+                                   &WebMediaTrackConstraintSet::sample_rate)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsSampleRate);
+  }
+  if (RequestUsesNumericConstraint(constraints,
+                                   &WebMediaTrackConstraintSet::sample_size)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsSampleSize);
+  }
+  if (RequestUsesDiscreteConstraint(
+          constraints, &WebMediaTrackConstraintSet::echo_cancellation)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsEchoCancellation);
+  }
+  if (RequestUsesNumericConstraint(constraints,
+                                   &WebMediaTrackConstraintSet::latency)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsLatency);
+  }
+  if (RequestUsesNumericConstraint(
+          constraints, &WebMediaTrackConstraintSet::channel_count)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsChannelCount);
+  }
+  if (RequestUsesDiscreteConstraint(constraints,
+                                    &WebMediaTrackConstraintSet::device_id)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsDeviceIdAudio);
+  }
+  if (RequestUsesDiscreteConstraint(
+          constraints, &WebMediaTrackConstraintSet::disable_local_echo)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsDisableLocalEcho);
+  }
+  if (RequestUsesDiscreteConstraint(constraints,
+                                    &WebMediaTrackConstraintSet::group_id)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsGroupIdAudio);
+  }
+  if (RequestUsesDiscreteConstraint(
+          constraints, &WebMediaTrackConstraintSet::media_stream_source)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsMediaStreamSourceAudio);
+  }
+  if (RequestUsesDiscreteConstraint(
+          constraints,
+          &WebMediaTrackConstraintSet::render_to_associated_sink)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsRenderToAssociatedSink);
+  }
+  if (RequestUsesDiscreteConstraint(
+          constraints, &WebMediaTrackConstraintSet::hotword_enabled)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsHotwordEnabled);
+  }
+  if (RequestUsesDiscreteConstraint(
+          constraints, &WebMediaTrackConstraintSet::goog_echo_cancellation)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsGoogEchoCancellation);
+  }
+  if (RequestUsesDiscreteConstraint(
+          constraints,
+          &WebMediaTrackConstraintSet::goog_experimental_echo_cancellation)) {
+    counter.Count(
+        UseCounter::kMediaStreamConstraintsGoogExperimentalEchoCancellation);
+  }
+  if (RequestUsesDiscreteConstraint(
+          constraints, &WebMediaTrackConstraintSet::goog_auto_gain_control)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsGoogAutoGainControl);
+  }
+  if (RequestUsesDiscreteConstraint(
+          constraints,
+          &WebMediaTrackConstraintSet::goog_experimental_auto_gain_control)) {
+    counter.Count(
+        UseCounter::kMediaStreamConstraintsGoogExperimentalAutoGainControl);
+  }
+  if (RequestUsesDiscreteConstraint(
+          constraints, &WebMediaTrackConstraintSet::goog_noise_suppression)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsGoogNoiseSuppression);
+  }
+  if (RequestUsesDiscreteConstraint(
+          constraints, &WebMediaTrackConstraintSet::goog_highpass_filter)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsGoogHighpassFilter);
+  }
+  if (RequestUsesDiscreteConstraint(
+          constraints,
+          &WebMediaTrackConstraintSet::goog_typing_noise_detection)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsGoogTypingNoiseDetection);
+  }
+  if (RequestUsesDiscreteConstraint(
+          constraints,
+          &WebMediaTrackConstraintSet::goog_experimental_noise_suppression)) {
+    counter.Count(
+        UseCounter::kMediaStreamConstraintsGoogExperimentalNoiseSuppression);
+  }
+  if (RequestUsesDiscreteConstraint(
+          constraints, &WebMediaTrackConstraintSet::goog_beamforming)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsGoogBeamforming);
+  }
+  if (RequestUsesDiscreteConstraint(
+          constraints, &WebMediaTrackConstraintSet::goog_array_geometry)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsGoogArrayGeometry);
+  }
+  if (RequestUsesDiscreteConstraint(
+          constraints, &WebMediaTrackConstraintSet::goog_audio_mirroring)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsGoogAudioMirroring);
+  }
+  if (RequestUsesDiscreteConstraint(
+          constraints,
+          &WebMediaTrackConstraintSet::goog_da_echo_cancellation)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsGoogDAEchoCancellation);
+  }
+
+  UseCounter::Count(context, UseCounter::kMediaStreamConstraintsAudio);
+  if (counter.IsUnconstrained()) {
+    UseCounter::Count(context,
+                      UseCounter::kMediaStreamConstraintsAudioUnconstrained);
+  }
+}
+
+void CountVideoConstraintUses(ExecutionContext* context,
+                              const WebMediaConstraints& constraints) {
+  FeatureCounter counter(context);
+  if (RequestUsesNumericConstraint(constraints,
+                                   &WebMediaTrackConstraintSet::width)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsWidth);
+  }
+  if (RequestUsesNumericConstraint(constraints,
+                                   &WebMediaTrackConstraintSet::height)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsHeight);
+  }
+  if (RequestUsesNumericConstraint(constraints,
+                                   &WebMediaTrackConstraintSet::aspect_ratio)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsAspectRatio);
+  }
+  if (RequestUsesNumericConstraint(constraints,
+                                   &WebMediaTrackConstraintSet::frame_rate)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsFrameRate);
+  }
+  if (RequestUsesDiscreteConstraint(constraints,
+                                    &WebMediaTrackConstraintSet::facing_mode)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsFacingMode);
+  }
+  if (RequestUsesDiscreteConstraint(constraints,
+                                    &WebMediaTrackConstraintSet::device_id)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsDeviceIdVideo);
+  }
+  if (RequestUsesDiscreteConstraint(constraints,
+                                    &WebMediaTrackConstraintSet::group_id)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsGroupIdVideo);
+  }
+  if (RequestUsesDiscreteConstraint(constraints,
+                                    &WebMediaTrackConstraintSet::video_kind)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsVideoKind);
+  }
+  if (RequestUsesNumericConstraint(constraints,
+                                   &WebMediaTrackConstraintSet::depth_near)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsDepthNear);
+  }
+  if (RequestUsesNumericConstraint(constraints,
+                                   &WebMediaTrackConstraintSet::depth_far)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsDepthFar);
+  }
+  if (RequestUsesNumericConstraint(
+          constraints, &WebMediaTrackConstraintSet::focal_length_x)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsFocalLengthX);
+  }
+  if (RequestUsesNumericConstraint(
+          constraints, &WebMediaTrackConstraintSet::focal_length_y)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsFocalLengthY);
+  }
+  if (RequestUsesDiscreteConstraint(
+          constraints, &WebMediaTrackConstraintSet::media_stream_source)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsMediaStreamSourceVideo);
+  }
+  if (RequestUsesDiscreteConstraint(
+          constraints, &WebMediaTrackConstraintSet::goog_noise_reduction)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsGoogNoiseReduction);
+  }
+  if (RequestUsesNumericConstraint(
+          constraints,
+          &WebMediaTrackConstraintSet::goog_power_line_frequency)) {
+    counter.Count(UseCounter::kMediaStreamConstraintsGoogPowerLineFrequency);
+  }
+
+  UseCounter::Count(context, UseCounter::kMediaStreamConstraintsVideo);
+  if (counter.IsUnconstrained()) {
+    UseCounter::Count(context,
+                      UseCounter::kMediaStreamConstraintsVideoUnconstrained);
+  }
+}
+
+WebMediaConstraints ParseOptions(ExecutionContext* context,
+                                 const BooleanOrMediaTrackConstraints& options,
+                                 MediaErrorState& error_state) {
   WebMediaConstraints constraints;
 
   Dictionary constraints_dictionary;
   if (options.isNull()) {
     // Do nothing.
   } else if (options.isMediaTrackConstraints()) {
     constraints = MediaConstraintsImpl::Create(
         context, options.getAsMediaTrackConstraints(), error_state);
   } else {
     DCHECK(options.isBoolean());
     if (options.getAsBoolean()) {
       constraints = MediaConstraintsImpl::Create();
     }
   }
 
   return constraints;
 }
 
+}  // namespace
+
 UserMediaRequest* UserMediaRequest::Create(
     ExecutionContext* context,
     UserMediaController* controller,
     const MediaStreamConstraints& options,
     NavigatorUserMediaSuccessCallback* success_callback,
     NavigatorUserMediaErrorCallback* error_callback,
     MediaErrorState& error_state) {
   WebMediaConstraints audio =
       ParseOptions(context, options.audio(), error_state);
   if (error_state.HadException())
     return nullptr;
 
   WebMediaConstraints video =
       ParseOptions(context, options.video(), error_state);
   if (error_state.HadException())
     return nullptr;
 
   if (audio.IsNull() && video.IsNull()) {
     error_state.ThrowTypeError(
         "At least one of audio and video must be requested");
     return nullptr;
   }
 
+  if (!audio.IsNull())
+    CountAudioConstraintUses(context, audio);
+  if (!video.IsNull())
+    CountVideoConstraintUses(context, video);
+
   return new UserMediaRequest(context, controller, audio, video,
                               success_callback, error_callback);
 }
 
 UserMediaRequest* UserMediaRequest::CreateForTesting(
     const WebMediaConstraints& audio,
     const WebMediaConstraints& video) {
   return new UserMediaRequest(nullptr, nullptr, audio, video, nullptr, nullptr);
 }
 
@@ skipping 125 matching lines @@
 }
 
 DEFINE_TRACE(UserMediaRequest) {
   visitor->Trace(controller_);
   visitor->Trace(success_callback_);
   visitor->Trace(error_callback_);
   ContextLifecycleObserver::Trace(visitor);
 }
 
 }  // namespace blink