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

device/capture/content/capture_resolution_chooser.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 <algorithm>
 #include <limits>
 
 #include "base/strings/string_util.h"
 #include "media/base/limits.h"
 #include "media/base/video_util.h"
 
-namespace media {
+namespace device {
 
 namespace {
 
 // Each snapped frame size is an integer multiple of this many lines apart.
 // This is ideal for 16:9 content, but seems to also work well for many
 // arbitrary aspect ratios.
 const int kSnappedHeightStep = 90;
 
 // The minimum amount of decrease in area between consecutive snapped frame
 // sizes.  This matters externally, where the end-to-end system is hunting for a
 // capture size that works within all resource bottlenecks.  If the snapped
 // frame sizes are too-close together, the end-to-end system cannot stablize.
 // If they are too-far apart, quality is being sacrificed.
 const int kMinAreaDecreasePercent = 15;
 
 // Compute the minimum frame size from the given |max_frame_size| and
 // |resolution_change_policy|.
 gfx::Size ComputeMinimumCaptureSize(
     const gfx::Size& max_frame_size,
     ResolutionChangePolicy resolution_change_policy) {
   switch (resolution_change_policy) {
-    case RESOLUTION_POLICY_FIXED_RESOLUTION:
+    case media::RESOLUTION_POLICY_FIXED_RESOLUTION:
       return max_frame_size;
-    case RESOLUTION_POLICY_FIXED_ASPECT_RATIO: {
+    case media::RESOLUTION_POLICY_FIXED_ASPECT_RATIO: {
       // TODO(miu): This is a place-holder until "min constraints" are plumbed-
       // in from the MediaStream framework.  http://crbug.com/473336
       const int kMinLines = 180;
       if (max_frame_size.height() <= kMinLines)
         return max_frame_size;
       const gfx::Size result(
           kMinLines * max_frame_size.width() / max_frame_size.height(),
           kMinLines);
-      if (result.width() <= 0 || result.width() > limits::kMaxDimension)
+      if (result.width() <= 0 || result.width() > media::limits::kMaxDimension)
         return max_frame_size;
       return result;
     }
-    case RESOLUTION_POLICY_ANY_WITHIN_LIMIT:
+    case media::RESOLUTION_POLICY_ANY_WITHIN_LIMIT:
       return gfx::Size(1, 1);
   }
   NOTREACHED();
   return gfx::Size(1, 1);
 }
 
 // Returns |size|, unless it exceeds |max_size| or is under |min_size|.  When
 // the bounds are exceeded, computes and returns an alternate size of similar
 // aspect ratio that is within the bounds.
 gfx::Size ComputeBoundedCaptureSize(const gfx::Size& size,
                                     const gfx::Size& min_size,
                                     const gfx::Size& max_size) {
   if (size.width() > max_size.width() || size.height() > max_size.height()) {
-    gfx::Size result = ScaleSizeToFitWithinTarget(size, max_size);
+    gfx::Size result = media::ScaleSizeToFitWithinTarget(size, max_size);
     result.SetToMax(min_size);
     return result;
   } else if (size.width() < min_size.width() ||
              size.height() < min_size.height()) {
-    gfx::Size result = ScaleSizeToEncompassTarget(size, min_size);
+    gfx::Size result = media::ScaleSizeToEncompassTarget(size, min_size);
     result.SetToMin(max_size);
     return result;
   } else {
     return size;
   }
 }
 
 // Returns true if the area of |a| is less than that of |b|.
 bool CompareByArea(const gfx::Size& a, const gfx::Size& b) {
   return a.GetArea() < b.GetArea();
 }
 
 }  // namespace
 
 CaptureResolutionChooser::CaptureResolutionChooser(
     const gfx::Size& max_frame_size,
     ResolutionChangePolicy resolution_change_policy)
     : max_frame_size_(max_frame_size),
       min_frame_size_(
           ComputeMinimumCaptureSize(max_frame_size, resolution_change_policy)),
       resolution_change_policy_(resolution_change_policy),
       target_area_(std::numeric_limits<decltype(target_area_)>::max()) {
   DCHECK_LT(0, max_frame_size_.width());
   DCHECK_LT(0, max_frame_size_.height());
   DCHECK_LE(min_frame_size_.width(), max_frame_size_.width());
   DCHECK_LE(min_frame_size_.height(), max_frame_size_.height());
-  DCHECK_LE(resolution_change_policy_, RESOLUTION_POLICY_LAST);
+  DCHECK_LE(resolution_change_policy_, media::RESOLUTION_POLICY_LAST);
 
   UpdateSnappedFrameSizes(max_frame_size_);
   RecomputeCaptureSize();
 }
 
 CaptureResolutionChooser::~CaptureResolutionChooser() {
 }
 
 void CaptureResolutionChooser::SetSourceSize(const gfx::Size& source_size) {
   if (source_size.IsEmpty())
     return;
 
   switch (resolution_change_policy_) {
-    case RESOLUTION_POLICY_FIXED_RESOLUTION:
+    case media::RESOLUTION_POLICY_FIXED_RESOLUTION:
       // Source size changes do not affect the frame resolution.  Frame
       // resolution is always fixed to |max_frame_size_|.
       break;
 
-    case RESOLUTION_POLICY_FIXED_ASPECT_RATIO:
+    case media::RESOLUTION_POLICY_FIXED_ASPECT_RATIO:
       UpdateSnappedFrameSizes(ComputeBoundedCaptureSize(
-          PadToMatchAspectRatio(source_size, max_frame_size_), min_frame_size_,
-          max_frame_size_));
+          media::PadToMatchAspectRatio(source_size, max_frame_size_),
+          min_frame_size_, max_frame_size_));
       RecomputeCaptureSize();
       break;
 
-    case RESOLUTION_POLICY_ANY_WITHIN_LIMIT:
+    case media::RESOLUTION_POLICY_ANY_WITHIN_LIMIT:
       UpdateSnappedFrameSizes(ComputeBoundedCaptureSize(
           source_size, min_frame_size_, max_frame_size_));
       RecomputeCaptureSize();
       break;
   }
 }
 
 void CaptureResolutionChooser::SetTargetFrameArea(int area) {
   DCHECK_GE(area, 0);
   target_area_ = area;
@@ skipping 95 matching lines @@
 
   if (VLOG_IS_ON(1)) {
     std::vector<std::string> stringified_sizes;
     for (const gfx::Size& size : snapped_sizes_)
       stringified_sizes.push_back(size.ToString());
     VLOG_STREAM(1) << "Recomputed snapped frame sizes: "
                    << base::JoinString(stringified_sizes, " <--> ");
   }
 }
 
-}  // namespace media
+}  // namespace device