move //media/capture to //device/capture

device/capture/content/capture_resolution_chooser_unittest.cc

 // Copyright 2015 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 "media/capture/content/capture_resolution_chooser.h"
+#include "device/capture/content/capture_resolution_chooser.h"
 
 #include <stddef.h>
 
 #include "base/location.h"
 #include "base/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using tracked_objects::Location;
 
-namespace media {
+namespace device {
 
 namespace {
 
 // 16:9 maximum and minimum frame sizes.
 const int kMaxFrameWidth = 3840;
 const int kMaxFrameHeight = 2160;
 const int kMinFrameWidth = 320;
 const int kMinFrameHeight = 180;
 
 // Checks whether |size| is strictly between (inclusive) |min_size| and
@@ skipping 159 matching lines @@
   chooser->SetTargetFrameArea(0);
   EXPECT_EQ(smallest_size, chooser->capture_size());
 }
 
 }  // namespace
 
 TEST(CaptureResolutionChooserTest,
      FixedResolutionPolicy_CaptureSizeAlwaysFixed) {
   const gfx::Size the_one_frame_size(kMaxFrameWidth, kMaxFrameHeight);
   CaptureResolutionChooser chooser(the_one_frame_size,
-                                   RESOLUTION_POLICY_FIXED_RESOLUTION);
+                                   media::RESOLUTION_POLICY_FIXED_RESOLUTION);
   EXPECT_EQ(the_one_frame_size, chooser.capture_size());
 
   chooser.SetSourceSize(the_one_frame_size);
   EXPECT_EQ(the_one_frame_size, chooser.capture_size());
 
   chooser.SetSourceSize(gfx::Size(kMaxFrameWidth + 424, kMaxFrameHeight - 101));
   EXPECT_EQ(the_one_frame_size, chooser.capture_size());
 
   chooser.SetSourceSize(gfx::Size(kMaxFrameWidth - 202, kMaxFrameHeight + 56));
   EXPECT_EQ(the_one_frame_size, chooser.capture_size());
@@ skipping 16 matching lines @@
   // frame size.
   chooser.SetTargetFrameArea(0);
   EXPECT_EQ(the_one_frame_size, chooser.capture_size());
   chooser.SetTargetFrameArea(the_one_frame_size.GetArea() / 2);
   EXPECT_EQ(the_one_frame_size, chooser.capture_size());
 }
 
 TEST(CaptureResolutionChooserTest,
      FixedAspectRatioPolicy_CaptureSizeHasSameAspectRatio) {
   CaptureResolutionChooser chooser(gfx::Size(kMaxFrameWidth, kMaxFrameHeight),
-                                   RESOLUTION_POLICY_FIXED_ASPECT_RATIO);
+                                   media::RESOLUTION_POLICY_FIXED_ASPECT_RATIO);
 
   // Starting condition.
   const gfx::Size min_size(kMinFrameWidth, kMinFrameHeight);
   const gfx::Size max_size(kMaxFrameWidth, kMaxFrameHeight);
   ExpectIsWithinBoundsAndSameAspectRatio(FROM_HERE, min_size, max_size,
                                          chooser.capture_size());
 
   // Max size in --> max size out.
   chooser.SetSourceSize(gfx::Size(kMaxFrameWidth, kMaxFrameHeight));
   ExpectIsWithinBoundsAndSameAspectRatio(FROM_HERE, min_size, max_size,
@@ skipping 51 matching lines @@
   const gfx::Size smallest_size(180 * kMaxFrameWidth / kMaxFrameHeight, 180);
 
   TestSnappedFrameSizes(&chooser, smallest_size);
   TestTargetedFrameAreas(&chooser, smallest_size);
 }
 
 TEST(CaptureResolutionChooserTest,
      AnyWithinLimitPolicy_CaptureSizeIsAnythingWithinLimits) {
   const gfx::Size max_size(kMaxFrameWidth, kMaxFrameHeight);
   CaptureResolutionChooser chooser(max_size,
-                                   RESOLUTION_POLICY_ANY_WITHIN_LIMIT);
+                                   media::RESOLUTION_POLICY_ANY_WITHIN_LIMIT);
 
   // Starting condition.
   EXPECT_EQ(max_size, chooser.capture_size());
 
   // Max size in --> max size out.
   chooser.SetSourceSize(max_size);
   EXPECT_EQ(max_size, chooser.capture_size());
 
   // Various source sizes within bounds.
   chooser.SetSourceSize(gfx::Size(640, 480));
@@ skipping 28 matching lines @@
 
   // For a chooser configured with the "any within limit" policy, the smallest
   // possible computed size is smallest non-empty snapped size (which is 90
   // lines of resolution) with the same aspect ratio as the maximum size.
   const gfx::Size smallest_size(90 * kMaxFrameWidth / kMaxFrameHeight, 90);
 
   TestSnappedFrameSizes(&chooser, smallest_size);
   TestTargetedFrameAreas(&chooser, smallest_size);
 }
 
-}  // namespace media
+}  // namespace device