Minor refactoring of support classes for video-device constraints.

content/renderer/media/media_stream_constraints_util_video_device.h

 // Copyright 2017 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.
 
-#ifndef CONTENT_RENDERER_MEDIA_MEDIA_STREAM_CONSTRAINTS_UTIL_VIDEO_SOURCE_H_
-#define CONTENT_RENDERER_MEDIA_MEDIA_STREAM_CONSTRAINTS_UTIL_VIDEO_SOURCE_H_
+#ifndef CONTENT_RENDERER_MEDIA_MEDIA_STREAM_CONSTRAINTS_UTIL_VIDEO_DEVICE_H_
+#define CONTENT_RENDERER_MEDIA_MEDIA_STREAM_CONSTRAINTS_UTIL_VIDEO_DEVICE_H_
 
-#include <iosfwd>
 #include <string>
 #include <vector>
 
 #include "content/common/content_export.h"
 #include "content/common/media/media_devices.mojom.h"
 #include "media/capture/video_capture_types.h"
 
 namespace blink {
 class WebString;
 class WebMediaConstraints;
 }
 
 namespace content {
 
 // Calculates and returns videoKind value for |format|.
 // See https://w3c.github.io/mediacapture-depth.
 blink::WebString CONTENT_EXPORT
 GetVideoKindForFormat(const media::VideoCaptureFormat& format);
 
-struct CONTENT_EXPORT VideoCaptureCapabilities {
-  VideoCaptureCapabilities();
-  VideoCaptureCapabilities(VideoCaptureCapabilities&& other);
-  ~VideoCaptureCapabilities();
-  VideoCaptureCapabilities& operator=(VideoCaptureCapabilities&& other);
+struct CONTENT_EXPORT VideoDeviceCaptureCapabilities {
+  VideoDeviceCaptureCapabilities();
+  VideoDeviceCaptureCapabilities(VideoDeviceCaptureCapabilities&& other);
+  ~VideoDeviceCaptureCapabilities();
+  VideoDeviceCaptureCapabilities& operator=(
+      VideoDeviceCaptureCapabilities&& other);
 
   // Each field is independent of each other.
   std::vector<::mojom::VideoInputDeviceCapabilitiesPtr> device_capabilities;
   std::vector<media::PowerLineFrequency> power_line_capabilities;
 };
 
-class CONTENT_EXPORT VideoCaptureSourceSettings {
- public:
-  VideoCaptureSourceSettings();
-  VideoCaptureSourceSettings(const VideoCaptureSourceSettings& other);
-  VideoCaptureSourceSettings(VideoCaptureSourceSettings&& other);
-  VideoCaptureSourceSettings(const std::string& device_id,
-                             const media::VideoCaptureFormat& format,
-                             ::mojom::FacingMode facing_mode,
-                             media::PowerLineFrequency power_line_frequency);
-  ~VideoCaptureSourceSettings();
-  VideoCaptureSourceSettings& operator=(
-      const VideoCaptureSourceSettings& other);
-  VideoCaptureSourceSettings& operator=(VideoCaptureSourceSettings&& other);
+struct CONTENT_EXPORT VideoDeviceCaptureSourceSelectionResult {
+  VideoDeviceCaptureSourceSelectionResult();
+  VideoDeviceCaptureSourceSelectionResult(
+      const VideoDeviceCaptureSourceSelectionResult& other);
+  VideoDeviceCaptureSourceSelectionResult(
+      VideoDeviceCaptureSourceSelectionResult&& other);
+  ~VideoDeviceCaptureSourceSelectionResult();
+  VideoDeviceCaptureSourceSelectionResult& operator=(
+      const VideoDeviceCaptureSourceSelectionResult& other);
+  VideoDeviceCaptureSourceSelectionResult& operator=(
+      VideoDeviceCaptureSourceSelectionResult&& other);
 
-  // Accessors for easier interaction with blink constraint classes.
-  blink::WebString GetFacingMode() const;
-  long GetPowerLineFrequency() const;
-  long GetWidth() const;
-  long GetHeight() const;
-  double GetFrameRate() const;
-  blink::WebString GetDeviceId() const;
-  blink::WebString GetVideoKind() const;
+  bool HasValue() const { return failed_constraint_name == nullptr; }
 
-  const media::VideoCaptureFormat& format() const { return format_; }
-  const std::string& device_id() const { return device_id_; }
-  ::mojom::FacingMode facing_mode() const { return facing_mode_; }
-  media::PowerLineFrequency power_line_frequency() const {
-    return power_line_frequency_;
+  // Convenience accessors for fields embedded in |capture_params|.
+  const media::VideoCaptureFormat& Format() const {
+    return capture_params.requested_format;
+  }
+  int Width() const {
+    return capture_params.requested_format.frame_size.width();
+  }
+  int Height() const {
+    return capture_params.requested_format.frame_size.width();
+  }
+  float FrameRate() const { return capture_params.requested_format.frame_rate; }
+  media::PowerLineFrequency PowerLineFrequency() const {
+    return capture_params.power_line_frequency;
   }

[hbos_chromium, 2017/02/24 11:28:57]

Here you use names like Width() but in VideoDeviceCaptureSourceSettings you use
names like GetWidth(). I'm OK with either but be consistent.

[Guido Urdaneta, 2017/02/24 13:13:44]

As discussed offline, the Get ones are not just accessors, but also make type
transformations to be more Blink friendly. Updated the comment for Get functions
to make that more clear.

 
- private:
-  std::string device_id_;
-  media::VideoCaptureFormat format_;
-  ::mojom::FacingMode facing_mode_;
-  media::PowerLineFrequency power_line_frequency_;
-};
-
-struct CONTENT_EXPORT VideoCaptureSourceSelectionResult {
-  VideoCaptureSourceSelectionResult();
-  VideoCaptureSourceSelectionResult(
-      const VideoCaptureSourceSelectionResult& other);
-  VideoCaptureSourceSelectionResult(VideoCaptureSourceSelectionResult&& other);
-  ~VideoCaptureSourceSelectionResult();
-  VideoCaptureSourceSelectionResult& operator=(
-      const VideoCaptureSourceSelectionResult& other);
-  VideoCaptureSourceSelectionResult& operator=(
-      VideoCaptureSourceSelectionResult&& other);
-
-  bool has_value() const { return failed_constraint_name == nullptr; }
-
-  VideoCaptureSourceSettings settings;
   const char* failed_constraint_name;
+  std::string device_id;
+  ::mojom::FacingMode facing_mode;
+  media::VideoCaptureParams capture_params;
 };
 
 // This function performs source and source-settings selection based on
 // the given |capabilities| and |constraints|.
 // Chromium performs constraint resolution in two steps. First, a source and its
 // settings are selected; then a track is created, connected to the source, and
 // finally the track settings are selected. This function implements an
 // algorithm for the first step. Sources are not a user-visible concept, so the
 // spec only specifies an algorithm for track settings.
 // This algorithm for sources is compatible with the spec algorithm for tracks,
@@ skipping 44 matching lines @@
 //    native resolution of 1200x1200, while C2 has a native resolution of
 //    2000x2000, then C1 is better because it can support the ideal value with
 //    lower resource usage. Both C1 and C2 are better than a candidate C3 with
 //    a native resolution of 999x999, since C3 has a nonzero distance to the
 //    ideal value and thus has worse fitness according to step 2, even if C3's
 //    native fitness is better than C1's and C2's.
 // 5. C1 is better than C2 if its settings are closer to certain default
 //    settings that include the device ID, power-line frequency, resolution, and
 //    frame rate, in that order. Note that there is no default facing mode or
 //    aspect ratio.
-VideoCaptureSourceSelectionResult CONTENT_EXPORT
-SelectVideoCaptureSourceSettings(const VideoCaptureCapabilities& capabilities,
-                                 const blink::WebMediaConstraints& constraints);
+VideoDeviceCaptureSourceSelectionResult CONTENT_EXPORT
+SelectVideoDeviceCaptureSourceSettings(
+    const VideoDeviceCaptureCapabilities& capabilities,
+    const blink::WebMediaConstraints& constraints);
 
 }  // namespace content
 
-#endif  // CONTENT_RENDERER_MEDIA_MEDIA_STREAM_CONSTRAINTS_UTIL_VIDEO_SOURCE_H_
+#endif  // CONTENT_RENDERER_MEDIA_MEDIA_STREAM_CONSTRAINTS_UTIL_VIDEO_DEVICE_H_