Move files video_capture*.* from media/base to media/capture

media/capture/video_capture_types.h

 // Copyright (c) 2012 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 MEDIA_BASE_VIDEO_CAPTURE_TYPES_H_
-#define MEDIA_BASE_VIDEO_CAPTURE_TYPES_H_
+#ifndef MEDIA_CAPTURE_VIDEO_CAPTURE_TYPES_H_
+#define MEDIA_CAPTURE_VIDEO_CAPTURE_TYPES_H_
 
 #include <stddef.h>
 
 #include <vector>
 
 #include "build/build_config.h"
-#include "media/base/media_export.h"
 #include "media/base/video_types.h"
+#include "media/capture/capture_export.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace media {
 
 // TODO(wjia): this type should be defined in a common place and
 // shared with device manager.
 typedef int VideoCaptureSessionId;
 
 // Storage type for the pixels.
 // TODO(mcasas): http://crbug.com/504160 Consider making this an enum class.
@@ skipping 46 matching lines @@
               "static_cast<int>(FREQUENCY_DEFAULT) must equal 60.");
 
 // Some drivers use rational time per frame instead of float frame rate, this
 // constant k is used to convert between both: A fps -> [k/k*A] seconds/frame.
 const int kFrameRatePrecision = 10000;
 
 // Video capture format specification.
 // This class is used by the video capture device to specify the format of every
 // frame captured and returned to a client. It is also used to specify a
 // supported capture format by a device.
-struct MEDIA_EXPORT VideoCaptureFormat {
+struct CAPTURE_EXPORT VideoCaptureFormat {
   VideoCaptureFormat();
   VideoCaptureFormat(const gfx::Size& frame_size,
                      float frame_rate,
                      VideoPixelFormat pixel_format);
   VideoCaptureFormat(const gfx::Size& frame_size,
                      float frame_rate,
                      VideoPixelFormat pixel_format,
                      VideoPixelStorage pixel_storage);
 
   static std::string ToString(const VideoCaptureFormat& format);
   static std::string PixelStorageToString(VideoPixelStorage storage);
 
   // Compares the priority of the pixel formats. Returns true if |lhs| is the
   // preferred pixel format in comparison with |rhs|. Returns false otherwise.
   static bool ComparePixelFormatPreference(const VideoPixelFormat& lhs,
                                            const VideoPixelFormat& rhs);
 
   // Returns the required buffer size to hold an image of a given
   // VideoCaptureFormat with no padding and tightly packed.
   size_t ImageAllocationSize() const;
 
   // Checks that all values are in the expected range. All limits are specified
   // in media::Limits.
   bool IsValid() const;
 
   bool operator==(const VideoCaptureFormat& other) const {
-    return frame_size == other.frame_size &&
-        frame_rate == other.frame_rate &&
-        pixel_format == other.pixel_format;
+    return frame_size == other.frame_size && frame_rate == other.frame_rate &&
+           pixel_format == other.pixel_format;
   }
 
   gfx::Size frame_size;
   float frame_rate;
   VideoPixelFormat pixel_format;
   VideoPixelStorage pixel_storage;
 };
 
 typedef std::vector<VideoCaptureFormat> VideoCaptureFormats;
 
@@ skipping 19 matching lines @@
 
   // Policy for resolution change.
   ResolutionChangePolicy resolution_change_policy;
 
   // User-specified power line frequency.
   PowerLineFrequency power_line_frequency;
 };
 
 }  // namespace media
 
-#endif  // MEDIA_BASE_VIDEO_CAPTURE_TYPES_H_
+#endif  // MEDIA_CAPTURE_VIDEO_CAPTURE_TYPES_H_