Change ResolutionChangePolicy from unscoped enum to enum class

Bug: 791427
Change-Id: Ic421215d3e77e1d6381512d29e1457fba15135ca
Reviewed-on: https://chromium-review.googlesource.com/796250
Commit-Queue: Shanmuga Pandi <shanmuga.m@samsung.com>
Reviewed-by: Yuri Wiitala <miu@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Miguel Casas <mcasas@chromium.org>
Cr-Commit-Position: refs/heads/master@{#521663}

content/browser/media/capture/desktop_capture_device_unittest.cc

@@ -350,7 +350,7 @@ TEST_F(DesktopCaptureDeviceTest, ScreenResolutionChangeConstantResolution) {
   capture_params.requested_format.frame_rate = kFrameRate;
   capture_params.requested_format.pixel_format = media::PIXEL_FORMAT_I420;
   capture_params.resolution_change_policy =
-      media::RESOLUTION_POLICY_FIXED_RESOLUTION;
+      media::ResolutionChangePolicy::FIXED_RESOLUTION;
 
   capture_device_->AllocateAndStart(capture_params, std::move(client));
 
@@ -399,7 +399,7 @@ TEST_F(DesktopCaptureDeviceTest, ScreenResolutionChangeFixedAspectRatio) {
   capture_params.requested_format.frame_rate = kFrameRate;
   capture_params.requested_format.pixel_format = media::PIXEL_FORMAT_I420;
   capture_params.resolution_change_policy =
-      media::RESOLUTION_POLICY_FIXED_ASPECT_RATIO;
+      media::ResolutionChangePolicy::FIXED_ASPECT_RATIO;
 
   capture_device_->AllocateAndStart(capture_params, std::move(client));
 
@@ -448,7 +448,7 @@ TEST_F(DesktopCaptureDeviceTest, ScreenResolutionChangeVariableResolution) {
   capture_params.requested_format.frame_rate = kFrameRate;
   capture_params.requested_format.pixel_format = media::PIXEL_FORMAT_I420;
   capture_params.resolution_change_policy =
-      media::RESOLUTION_POLICY_ANY_WITHIN_LIMIT;
+      media::ResolutionChangePolicy::ANY_WITHIN_LIMIT;
 
   capture_device_->AllocateAndStart(capture_params, std::move(client));
 

content/browser/media/capture/web_contents_video_capture_device.cc

@@ -568,10 +568,10 @@ gfx::Size WebContentsCaptureMachine::ComputeOptimalViewSize() const {
   gfx::Size optimal_size = oracle_proxy_->max_frame_size();
 
   switch (capture_params_.resolution_change_policy) {
-    case media::RESOLUTION_POLICY_FIXED_RESOLUTION:
+    case media::ResolutionChangePolicy::FIXED_RESOLUTION:
       break;
-    case media::RESOLUTION_POLICY_FIXED_ASPECT_RATIO:
-    case media::RESOLUTION_POLICY_ANY_WITHIN_LIMIT: {
+    case media::ResolutionChangePolicy::FIXED_ASPECT_RATIO:
+    case media::ResolutionChangePolicy::ANY_WITHIN_LIMIT: {
       // If the max frame size is close to a common video aspect ratio, compute
       // a standard resolution for that aspect ratio.  For example, given
       // 1365x768, which is very close to 16:9, the optimal size would be

content/browser/media/capture/web_contents_video_capture_device_unittest.cc

@@ -795,7 +795,7 @@ TEST_F(WebContentsVideoCaptureDeviceTest, GoesThroughAllTheMotions) {
 TEST_F(WebContentsVideoCaptureDeviceTest, VariableResolution_FixedAspectRatio) {
   media::VideoCaptureParams capture_params = DefaultCaptureParams();
   capture_params.resolution_change_policy =
-      media::RESOLUTION_POLICY_FIXED_ASPECT_RATIO;
+      media::ResolutionChangePolicy::FIXED_ASPECT_RATIO;
   std::unique_ptr<StubClient> client = client_observer()->PassClient();
   EXPECT_CALL(*client, OnStarted());
   device()->AllocateAndStart(capture_params, std::move(client));
@@ -843,7 +843,7 @@ TEST_F(WebContentsVideoCaptureDeviceTest, VariableResolution_FixedAspectRatio) {
 TEST_F(WebContentsVideoCaptureDeviceTest, VariableResolution_AnyWithinLimits) {
   media::VideoCaptureParams capture_params = DefaultCaptureParams();
   capture_params.resolution_change_policy =
-      media::RESOLUTION_POLICY_ANY_WITHIN_LIMIT;
+      media::ResolutionChangePolicy::ANY_WITHIN_LIMIT;
   std::unique_ptr<StubClient> client = client_observer()->PassClient();
   EXPECT_CALL(*client, OnStarted());
   device()->AllocateAndStart(capture_params, std::move(client));
@@ -893,12 +893,11 @@ TEST_F(WebContentsVideoCaptureDeviceTest,
        ComputesStandardResolutionsForPreferredSize) {
   // Helper function to run the same testing procedure for multiple combinations
   // of |policy|, |standard_size| and |oddball_size|.
-  const auto RunTestForPreferredSize =
-      [=](media::ResolutionChangePolicy policy,
-          const gfx::Size& oddball_size,
-          const gfx::Size& standard_size) {
+  const auto RunTestForPreferredSize = [=](media::ResolutionChangePolicy policy,
+                                           const gfx::Size& oddball_size,
+                                           const gfx::Size& standard_size) {
     SCOPED_TRACE(::testing::Message()
-                 << "policy=" << policy
+                 << "policy=" << static_cast<int>(policy)
                  << ", oddball_size=" << oddball_size.ToString()
                  << ", standard_size=" << standard_size.ToString());
 
@@ -907,8 +906,9 @@ TEST_F(WebContentsVideoCaptureDeviceTest,
     // variable-resolution cases, the |standard_size| is the expected size.
     // Also, adjust to account for the device scale factor.
     gfx::Size capture_preferred_size = gfx::ScaleToFlooredSize(
-        policy == media::RESOLUTION_POLICY_FIXED_RESOLUTION ? oddball_size
-                                                            : standard_size,
+        policy == media::ResolutionChangePolicy::FIXED_RESOLUTION
+            ? oddball_size
+            : standard_size,
         1.0f / GetDeviceScaleFactor());
     ASSERT_NE(capture_preferred_size, web_contents()->GetPreferredSize());
 
@@ -932,9 +932,9 @@ TEST_F(WebContentsVideoCaptureDeviceTest,
   };
 
   const media::ResolutionChangePolicy policies[3] = {
-    media::RESOLUTION_POLICY_FIXED_RESOLUTION,
-    media::RESOLUTION_POLICY_FIXED_ASPECT_RATIO,
-    media::RESOLUTION_POLICY_ANY_WITHIN_LIMIT,
+      media::ResolutionChangePolicy::FIXED_RESOLUTION,
+      media::ResolutionChangePolicy::FIXED_ASPECT_RATIO,
+      media::ResolutionChangePolicy::ANY_WITHIN_LIMIT,
   };
 
   for (size_t i = 0; i < arraysize(policies); ++i) {

content/renderer/media/media_stream_constraints_util_video_content.cc

@@ -141,7 +141,7 @@ media::ResolutionChangePolicy SelectResolutionPolicyFromCandidates(
       resolution_set.min_width() > kMinScreenCastDimension) {
     if (resolution_set.min_height() == resolution_set.max_height() &&
         resolution_set.min_width() == resolution_set.max_width()) {
-      return media::RESOLUTION_POLICY_FIXED_RESOLUTION;
+      return media::ResolutionChangePolicy::FIXED_RESOLUTION;
     }
 
     int approx_aspect_ratio_min_resolution =
@@ -150,10 +150,10 @@ media::ResolutionChangePolicy SelectResolutionPolicyFromCandidates(
         100 * resolution_set.max_width() / resolution_set.max_height();
     if (approx_aspect_ratio_min_resolution ==
         approx_aspect_ratio_max_resolution) {
-      return media::RESOLUTION_POLICY_FIXED_ASPECT_RATIO;
+      return media::ResolutionChangePolicy::FIXED_ASPECT_RATIO;
     }
 
-    return media::RESOLUTION_POLICY_ANY_WITHIN_LIMIT;
+    return media::ResolutionChangePolicy::ANY_WITHIN_LIMIT;
   }
 
   return default_policy;
@@ -299,8 +299,8 @@ VideoCaptureSettings SelectResultFromCandidates(
   // This default comes from the old algorithm.
   media::ResolutionChangePolicy default_resolution_policy =
       stream_source == kMediaStreamSourceTab
-          ? media::RESOLUTION_POLICY_FIXED_RESOLUTION
-          : media::RESOLUTION_POLICY_ANY_WITHIN_LIMIT;
+          ? media::ResolutionChangePolicy::FIXED_RESOLUTION
+          : media::ResolutionChangePolicy::ANY_WITHIN_LIMIT;
 
   media::VideoCaptureParams capture_params =
       SelectVideoCaptureParamsFromCandidates(

content/renderer/media/media_stream_constraints_util_video_content_unittest.cc

@@ -2024,7 +2024,7 @@ TEST_F(MediaStreamConstraintsUtilVideoContentTest, ResolutionChangePolicy) {
     EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
     EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
     // Resolution can be adjusted.
-    EXPECT_EQ(media::RESOLUTION_POLICY_ANY_WITHIN_LIMIT,
+    EXPECT_EQ(media::ResolutionChangePolicy::ANY_WITHIN_LIMIT,
               result.ResolutionChangePolicy());
     CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
   }
@@ -2034,7 +2034,7 @@ TEST_F(MediaStreamConstraintsUtilVideoContentTest, ResolutionChangePolicy) {
     EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
     EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
     // Default policy for tab capture is fixed resolution.
-    EXPECT_EQ(media::RESOLUTION_POLICY_FIXED_RESOLUTION,
+    EXPECT_EQ(media::ResolutionChangePolicy::FIXED_RESOLUTION,
               result.ResolutionChangePolicy());
     CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
   }
@@ -2047,7 +2047,7 @@ TEST_F(MediaStreamConstraintsUtilVideoContentTest, ResolutionChangePolicy) {
     EXPECT_EQ(470, result.Height());
     // Resolution can be adjusted because ideal was used to select the
     // resolution.
-    EXPECT_EQ(media::RESOLUTION_POLICY_ANY_WITHIN_LIMIT,
+    EXPECT_EQ(media::ResolutionChangePolicy::ANY_WITHIN_LIMIT,
               result.ResolutionChangePolicy());
     CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(result);
   }
@@ -2058,7 +2058,7 @@ TEST_F(MediaStreamConstraintsUtilVideoContentTest, ResolutionChangePolicy) {
     auto result = SelectSettings();
     EXPECT_EQ(640, result.Width());
     EXPECT_EQ(480, result.Height());
-    EXPECT_EQ(media::RESOLUTION_POLICY_FIXED_RESOLUTION,
+    EXPECT_EQ(media::ResolutionChangePolicy::FIXED_RESOLUTION,
               result.ResolutionChangePolicy());
     EXPECT_EQ(640.0 / 480.0, result.track_adapter_settings().min_aspect_ratio);
     EXPECT_EQ(640.0 / 480.0, result.track_adapter_settings().max_aspect_ratio);
@@ -2071,7 +2071,7 @@ TEST_F(MediaStreamConstraintsUtilVideoContentTest, ResolutionChangePolicy) {
     auto result = SelectSettings();
     EXPECT_EQ(1000, result.Width());
     EXPECT_EQ(500, result.Height());
-    EXPECT_EQ(media::RESOLUTION_POLICY_FIXED_RESOLUTION,
+    EXPECT_EQ(media::ResolutionChangePolicy::FIXED_RESOLUTION,
               result.ResolutionChangePolicy());
     EXPECT_EQ(1000.0 / 500.0, result.track_adapter_settings().min_aspect_ratio);
     EXPECT_EQ(1000.0 / 500.0, result.track_adapter_settings().max_aspect_ratio);
@@ -2084,7 +2084,7 @@ TEST_F(MediaStreamConstraintsUtilVideoContentTest, ResolutionChangePolicy) {
     auto result = SelectSettings();
     EXPECT_EQ(630, result.Width());
     EXPECT_EQ(470, result.Height());
-    EXPECT_EQ(media::RESOLUTION_POLICY_FIXED_RESOLUTION,
+    EXPECT_EQ(media::ResolutionChangePolicy::FIXED_RESOLUTION,
               result.ResolutionChangePolicy());
     EXPECT_EQ(630.0 / 470.0, result.track_adapter_settings().min_aspect_ratio);
     EXPECT_EQ(630.0 / 470.0, result.track_adapter_settings().max_aspect_ratio);
@@ -2101,7 +2101,7 @@ TEST_F(MediaStreamConstraintsUtilVideoContentTest, ResolutionChangePolicy) {
     EXPECT_EQ(600, result.Height());
     // When the aspect ratio of the max resolution equals the aspect ratio of
     // the min resolution, the algorithm sets fixed aspect ratio policy.
-    EXPECT_EQ(media::RESOLUTION_POLICY_FIXED_ASPECT_RATIO,
+    EXPECT_EQ(media::ResolutionChangePolicy::FIXED_ASPECT_RATIO,
               result.ResolutionChangePolicy());
     CheckTrackAdapterSettingsEqualsFormat(result);
   }
@@ -2116,7 +2116,7 @@ TEST_F(MediaStreamConstraintsUtilVideoContentTest, ResolutionChangePolicy) {
     EXPECT_EQ(600, result.Height());
     // When the aspect ratio of the max resolution differs from the aspect ratio
     // of the min resolution, the algorithm sets any-within-limit policy.
-    EXPECT_EQ(media::RESOLUTION_POLICY_ANY_WITHIN_LIMIT,
+    EXPECT_EQ(media::ResolutionChangePolicy::ANY_WITHIN_LIMIT,
               result.ResolutionChangePolicy());
     CheckTrackAdapterSettingsEqualsFormat(result);
   }
@@ -2128,7 +2128,7 @@ TEST_F(MediaStreamConstraintsUtilVideoContentTest, ResolutionChangePolicy) {
     EXPECT_EQ(4000, result.Width());
     EXPECT_EQ(4000, result.Height());
     // Only specifying a maximum resolution allows resolution adjustment.
-    EXPECT_EQ(media::RESOLUTION_POLICY_ANY_WITHIN_LIMIT,
+    EXPECT_EQ(media::ResolutionChangePolicy::ANY_WITHIN_LIMIT,
               result.ResolutionChangePolicy());
     EXPECT_EQ(1.0 / 4000, result.track_adapter_settings().min_aspect_ratio);
     EXPECT_EQ(4000.0, result.track_adapter_settings().max_aspect_ratio);

content/renderer/media/user_media_client_impl_unittest.cc

@@ -957,7 +957,7 @@ TEST_F(UserMediaClientImplTest, DefaultConstraintsPropagate) {
   EXPECT_EQ(video_capture_settings.FrameRate(),
             MediaStreamVideoSource::kDefaultFrameRate);
   EXPECT_EQ(video_capture_settings.ResolutionChangePolicy(),
-            media::RESOLUTION_POLICY_FIXED_RESOLUTION);
+            media::ResolutionChangePolicy::FIXED_RESOLUTION);
   EXPECT_EQ(video_capture_settings.PowerLineFrequency(),
             media::PowerLineFrequency::FREQUENCY_DEFAULT);
   EXPECT_FALSE(video_capture_settings.noise_reduction());
@@ -1020,7 +1020,7 @@ TEST_F(UserMediaClientImplTest, DefaultTabCapturePropagate) {
   EXPECT_EQ(video_capture_settings.Height(), kDefaultScreenCastHeight);
   EXPECT_EQ(video_capture_settings.FrameRate(), kDefaultScreenCastFrameRate);
   EXPECT_EQ(video_capture_settings.ResolutionChangePolicy(),
-            media::RESOLUTION_POLICY_FIXED_RESOLUTION);
+            media::ResolutionChangePolicy::FIXED_RESOLUTION);
   EXPECT_EQ(video_capture_settings.PowerLineFrequency(),
             media::PowerLineFrequency::FREQUENCY_DEFAULT);
   EXPECT_FALSE(video_capture_settings.noise_reduction());
@@ -1083,7 +1083,7 @@ TEST_F(UserMediaClientImplTest, DefaultDesktopCapturePropagate) {
   EXPECT_EQ(video_capture_settings.Height(), kDefaultScreenCastHeight);
   EXPECT_EQ(video_capture_settings.FrameRate(), kDefaultScreenCastFrameRate);
   EXPECT_EQ(video_capture_settings.ResolutionChangePolicy(),
-            media::RESOLUTION_POLICY_ANY_WITHIN_LIMIT);
+            media::ResolutionChangePolicy::ANY_WITHIN_LIMIT);
   EXPECT_EQ(video_capture_settings.PowerLineFrequency(),
             media::PowerLineFrequency::FREQUENCY_DEFAULT);
   EXPECT_FALSE(video_capture_settings.noise_reduction());

media/capture/mojo/video_capture_types_struct_traits.cc

@@ -33,11 +33,11 @@ EnumTraits<media::mojom::ResolutionChangePolicy,
            media::ResolutionChangePolicy>::ToMojom(media::ResolutionChangePolicy
                                                        input) {
   switch (input) {
-    case media::RESOLUTION_POLICY_FIXED_RESOLUTION:
+    case media::ResolutionChangePolicy::FIXED_RESOLUTION:
       return media::mojom::ResolutionChangePolicy::FIXED_RESOLUTION;
-    case media::RESOLUTION_POLICY_FIXED_ASPECT_RATIO:
+    case media::ResolutionChangePolicy::FIXED_ASPECT_RATIO:
       return media::mojom::ResolutionChangePolicy::FIXED_ASPECT_RATIO;
-    case media::RESOLUTION_POLICY_ANY_WITHIN_LIMIT:
+    case media::ResolutionChangePolicy::ANY_WITHIN_LIMIT:
       return media::mojom::ResolutionChangePolicy::ANY_WITHIN_LIMIT;
   }
   NOTREACHED();
@@ -51,13 +51,13 @@ bool EnumTraits<media::mojom::ResolutionChangePolicy,
               media::ResolutionChangePolicy* output) {
   switch (input) {
     case media::mojom::ResolutionChangePolicy::FIXED_RESOLUTION:
-      *output = media::RESOLUTION_POLICY_FIXED_RESOLUTION;
+      *output = media::ResolutionChangePolicy::FIXED_RESOLUTION;
       return true;
     case media::mojom::ResolutionChangePolicy::FIXED_ASPECT_RATIO:
-      *output = media::RESOLUTION_POLICY_FIXED_ASPECT_RATIO;
+      *output = media::ResolutionChangePolicy::FIXED_ASPECT_RATIO;
       return true;
     case media::mojom::ResolutionChangePolicy::ANY_WITHIN_LIMIT:
-      *output = media::RESOLUTION_POLICY_ANY_WITHIN_LIMIT;
+      *output = media::ResolutionChangePolicy::ANY_WITHIN_LIMIT;
       return true;
   }
   NOTREACHED();

media/capture/video_capture_types.cc

@@ -96,13 +96,13 @@ bool VideoCaptureFormat::ComparePixelFormatPreference(
 }
 
 VideoCaptureParams::VideoCaptureParams()
-    : resolution_change_policy(RESOLUTION_POLICY_FIXED_RESOLUTION),
+    : resolution_change_policy(ResolutionChangePolicy::FIXED_RESOLUTION),
       power_line_frequency(PowerLineFrequency::FREQUENCY_DEFAULT) {}
 
 bool VideoCaptureParams::IsValid() const {
   return requested_format.IsValid() &&
-         resolution_change_policy >= RESOLUTION_POLICY_FIXED_RESOLUTION &&
-         resolution_change_policy <= RESOLUTION_POLICY_LAST &&
+         resolution_change_policy >= ResolutionChangePolicy::FIXED_RESOLUTION &&
+         resolution_change_policy <= ResolutionChangePolicy::LAST &&
          power_line_frequency >= PowerLineFrequency::FREQUENCY_DEFAULT &&
          power_line_frequency <= PowerLineFrequency::FREQUENCY_MAX;
 }
@@ -121,11 +121,11 @@ VideoCaptureParams::SuggestConstraints() const {
   // policy.
   gfx::Size min_frame_size;
   switch (resolution_change_policy) {
-    case RESOLUTION_POLICY_FIXED_RESOLUTION:
+    case ResolutionChangePolicy::FIXED_RESOLUTION:
       min_frame_size = max_frame_size;
       break;
 
-    case RESOLUTION_POLICY_FIXED_ASPECT_RATIO: {
+    case ResolutionChangePolicy::FIXED_ASPECT_RATIO: {
       // TODO(miu): This is a place-holder until "min constraints" are plumbed-
       // in from the MediaStream framework.  http://crbug.com/473336
       constexpr int kMinLines = 180;
@@ -146,7 +146,7 @@ VideoCaptureParams::SuggestConstraints() const {
       break;
     }
 
-    case RESOLUTION_POLICY_ANY_WITHIN_LIMIT:
+    case ResolutionChangePolicy::ANY_WITHIN_LIMIT:
       if (!max_frame_size.IsEmpty())
         min_frame_size = gfx::Size(2, 2);
       break;
@@ -156,7 +156,7 @@ VideoCaptureParams::SuggestConstraints() const {
 
   return SuggestedConstraints{
       min_frame_size, max_frame_size,
-      resolution_change_policy == RESOLUTION_POLICY_FIXED_ASPECT_RATIO};
+      resolution_change_policy == ResolutionChangePolicy::FIXED_ASPECT_RATIO};
 }
 
 }  // namespace media

media/capture/video_capture_types.h

@@ -31,23 +31,23 @@ enum class VideoPixelStorage {
 // It is up to the implementation how the captured content will be transformed
 // (e.g., scaling and/or letterboxing) in order to produce video frames that
 // strictly adheree to one of these policies.
-enum ResolutionChangePolicy {
+enum class ResolutionChangePolicy {
   // Capture device outputs a fixed resolution all the time. The resolution of
   // the first frame is the resolution for all frames.
-  RESOLUTION_POLICY_FIXED_RESOLUTION,
+  FIXED_RESOLUTION,
 
   // Capture device is allowed to output frames of varying resolutions. The
   // width and height will not exceed the maximum dimensions specified. The
   // aspect ratio of the frames will match the aspect ratio of the maximum
   // dimensions as closely as possible.
-  RESOLUTION_POLICY_FIXED_ASPECT_RATIO,
+  FIXED_ASPECT_RATIO,
 
   // Capture device is allowed to output frames of varying resolutions not
   // exceeding the maximum dimensions specified.
-  RESOLUTION_POLICY_ANY_WITHIN_LIMIT,
+  ANY_WITHIN_LIMIT,
 
   // Must always be equal to largest entry in the enum.
-  RESOLUTION_POLICY_LAST = RESOLUTION_POLICY_ANY_WITHIN_LIMIT,
+  LAST = ANY_WITHIN_LIMIT,
 };
 
 // Potential values of the googPowerLineFrequency optional constraint passed to

media/capture/video_capture_types_unittest.cc

@@ -39,35 +39,35 @@ TEST(VideoCaptureTypesTest, SuggestsConstraints) {
 
   // Test: Fixed 1080p resolution.
   params.requested_format.frame_size = gfx::Size(1920, 1080);
-  params.resolution_change_policy = RESOLUTION_POLICY_FIXED_RESOLUTION;
+  params.resolution_change_policy = ResolutionChangePolicy::FIXED_RESOLUTION;
   ExpectEqualConstraints(SuggestedConstraints({gfx::Size(1920, 1080),
                                                gfx::Size(1920, 1080), false}),
                          params.SuggestConstraints());
 
   // Test: Max 1080p resolution, fixed aspect ratio.
   params.requested_format.frame_size = gfx::Size(1920, 1080);
-  params.resolution_change_policy = RESOLUTION_POLICY_FIXED_ASPECT_RATIO;
+  params.resolution_change_policy = ResolutionChangePolicy::FIXED_ASPECT_RATIO;
   ExpectEqualConstraints(
       SuggestedConstraints({gfx::Size(320, 180), gfx::Size(1920, 1080), true}),
       params.SuggestConstraints());
 
   // Test: Max 1080p resolution, any aspect ratio.
   params.requested_format.frame_size = gfx::Size(1920, 1080);
-  params.resolution_change_policy = RESOLUTION_POLICY_ANY_WITHIN_LIMIT;
+  params.resolution_change_policy = ResolutionChangePolicy::ANY_WITHIN_LIMIT;
   ExpectEqualConstraints(
       SuggestedConstraints({gfx::Size(2, 2), gfx::Size(1920, 1080), false}),
       params.SuggestConstraints());
 
   // Test: Odd-valued resolution, fixed aspect ratio.
   params.requested_format.frame_size = gfx::Size(999, 777);
-  params.resolution_change_policy = RESOLUTION_POLICY_FIXED_ASPECT_RATIO;
+  params.resolution_change_policy = ResolutionChangePolicy::FIXED_ASPECT_RATIO;
   ExpectEqualConstraints(
       SuggestedConstraints({gfx::Size(232, 180), gfx::Size(998, 776), true}),
       params.SuggestConstraints());
 
   // Test: Max resolution less the hard-coded 180-line minimum, fixed aspect.
   params.requested_format.frame_size = gfx::Size(160, 90);
-  params.resolution_change_policy = RESOLUTION_POLICY_FIXED_ASPECT_RATIO;
+  params.resolution_change_policy = ResolutionChangePolicy::FIXED_ASPECT_RATIO;
   ExpectEqualConstraints(
       SuggestedConstraints({gfx::Size(160, 90), gfx::Size(160, 90), true}),
       params.SuggestConstraints());

services/video_capture/test/fake_device_descriptor_unittest.cc

@@ -88,7 +88,7 @@ TEST_F(FakeVideoCaptureDeviceDescriptorTest, CanUseSecondRequestedProxy) {
   arbitrary_requested_settings.requested_format.frame_size.SetSize(640, 480);
   arbitrary_requested_settings.requested_format.frame_rate = 15;
   arbitrary_requested_settings.resolution_change_policy =
-      media::RESOLUTION_POLICY_FIXED_RESOLUTION;
+      media::ResolutionChangePolicy::FIXED_RESOLUTION;
   arbitrary_requested_settings.power_line_frequency =
       media::PowerLineFrequency::FREQUENCY_DEFAULT;
 

services/video_capture/test/fake_device_test.cc

@@ -23,7 +23,7 @@ void FakeDeviceTest::SetUp() {
 
   requestable_settings_.requested_format = fake_device_first_supported_format_;
   requestable_settings_.resolution_change_policy =
-      media::RESOLUTION_POLICY_FIXED_RESOLUTION;
+      media::ResolutionChangePolicy::FIXED_RESOLUTION;
   requestable_settings_.power_line_frequency =
       media::PowerLineFrequency::FREQUENCY_DEFAULT;
 

services/video_capture/test/mock_device_test.cc

@@ -107,7 +107,7 @@ void MockDeviceTest::SetUp() {
   requested_settings_.requested_format.frame_size = gfx::Size(800, 600);
   requested_settings_.requested_format.frame_rate = 15;
   requested_settings_.resolution_change_policy =
-      media::RESOLUTION_POLICY_FIXED_RESOLUTION;
+      media::ResolutionChangePolicy::FIXED_RESOLUTION;
   requested_settings_.power_line_frequency =
       media::PowerLineFrequency::FREQUENCY_DEFAULT;