Test X11 header pollution

media/gpu/v4l2_device.cc

 // Copyright 2014 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 <libdrm/drm_fourcc.h>
 #include <linux/videodev2.h>
 #include <string.h>
 
 #include "base/numerics/safe_conversions.h"
 #include "build/build_config.h"
-#include "content/common/gpu/media/generic_v4l2_device.h"
+#include "media/gpu/generic_v4l2_device.h"
 #if defined(ARCH_CPU_ARMEL)
-#include "content/common/gpu/media/tegra_v4l2_device.h"
+#include "media/gpu/tegra_v4l2_device.h"
 #endif
 
-namespace content {
+namespace media {
 
-V4L2Device::V4L2Device(Type type) : type_(type) {
-}
+V4L2Device::V4L2Device(Type type) : type_(type) {}
 
-V4L2Device::~V4L2Device() {
-}
+V4L2Device::~V4L2Device() {}
 
 // static
 scoped_refptr<V4L2Device> V4L2Device::Create(Type type) {
   DVLOG(3) << __PRETTY_FUNCTION__;
 
   scoped_refptr<GenericV4L2Device> generic_device(new GenericV4L2Device(type));
   if (generic_device->Initialize())
     return generic_device;
 
 #if defined(ARCH_CPU_ARMEL)
@@ skipping 46 matching lines @@
     default:
       LOG(FATAL) << "Add more cases as needed";
       return 0;
   }
 }
 
 // static
 uint32_t V4L2Device::VideoCodecProfileToV4L2PixFmt(
     media::VideoCodecProfile profile,
     bool slice_based) {
-  if (profile >= media::H264PROFILE_MIN &&
-      profile <= media::H264PROFILE_MAX) {
+  if (profile >= media::H264PROFILE_MIN && profile <= media::H264PROFILE_MAX) {
     if (slice_based)
       return V4L2_PIX_FMT_H264_SLICE;
     else
       return V4L2_PIX_FMT_H264;
   } else if (profile >= media::VP8PROFILE_MIN &&
              profile <= media::VP8PROFILE_MAX) {
     if (slice_based)
       return V4L2_PIX_FMT_VP8_FRAME;
     else
       return V4L2_PIX_FMT_VP8;
@@ skipping 137 matching lines @@
       max_resolution->SetSize(frame_size.stepwise.max_width,
                               frame_size.stepwise.max_height);
       min_resolution->SetSize(frame_size.stepwise.min_width,
                               frame_size.stepwise.min_height);
       break;
     }
   }
   if (max_resolution->IsEmpty()) {
     max_resolution->SetSize(1920, 1088);
     LOG(ERROR) << "GetSupportedResolution failed to get maximum resolution for "
-               << "fourcc " << std::hex << pixelformat
-               << ", fall back to " << max_resolution->ToString();
+               << "fourcc " << std::hex << pixelformat << ", fall back to "
+               << max_resolution->ToString();
   }
   if (min_resolution->IsEmpty()) {
     min_resolution->SetSize(16, 16);
     LOG(ERROR) << "GetSupportedResolution failed to get minimum resolution for "
-               << "fourcc " << std::hex << pixelformat
-               << ", fall back to " << min_resolution->ToString();
+               << "fourcc " << std::hex << pixelformat << ", fall back to "
+               << min_resolution->ToString();
   }
 }
 
 media::VideoDecodeAccelerator::SupportedProfiles
 V4L2Device::GetSupportedDecodeProfiles(const size_t num_formats,
                                        const uint32_t pixelformats[]) {
   DCHECK_EQ(type_, kDecoder);
   media::VideoDecodeAccelerator::SupportedProfiles profiles;
   media::VideoDecodeAccelerator::SupportedProfile profile;
   v4l2_fmtdesc fmtdesc;
@@ skipping 48 matching lines @@
   // Try to find requested profile among the returned supported_profiles.
   const auto iter = std::find_if(
       supported_profiles.begin(), supported_profiles.end(),
       [profile](const media::VideoDecodeAccelerator::SupportedProfile& p) {
         return profile == p.profile;
       });
 
   return iter != supported_profiles.end();
 }
 
-}  //  namespace content
+}  //  namespace media