Test X11 header pollution

media/gpu/tegra_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 <dlfcn.h>
 #include <fcntl.h>
 #include <linux/videodev2.h>
 
 #include "base/lazy_instance.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/trace_event/trace_event.h"
-#include "content/common/gpu/media/tegra_v4l2_device.h"
+#include "media/gpu/tegra_v4l2_device.h"
 #include "ui/gl/gl_bindings.h"
 
-namespace content {
+namespace media {
 
 namespace {
 const char kDecoderDevice[] = "/dev/tegra_avpchannel";
 const char kEncoderDevice[] = "/dev/nvhost-msenc";
 }
 
 typedef int32_t (*TegraV4L2Open)(const char* name, int32_t flags);
 typedef int32_t (*TegraV4L2Close)(int32_t fd);
 typedef int32_t (*TegraV4L2Ioctl)(int32_t fd, unsigned long cmd, ...);
 typedef int32_t (*TegraV4L2Poll)(int32_t fd,
@@ skipping 60 matching lines @@
   bool initialized() { return initialized_; }
 
  private:
   bool initialized_;
 };
 
 base::LazyInstance<TegraFunctionSymbolFinder> g_tegra_function_symbol_finder_ =
     LAZY_INSTANCE_INITIALIZER;
 
 TegraV4L2Device::TegraV4L2Device(Type type)
-    : V4L2Device(type),
-      device_fd_(-1) {
-}
+    : V4L2Device(type), device_fd_(-1) {}
 
 TegraV4L2Device::~TegraV4L2Device() {
   if (device_fd_ != -1) {
     TegraV4L2_Close(device_fd_);
     device_fd_ = -1;
   }
 }
 
 int TegraV4L2Device::Ioctl(int flags, void* arg) {
   return HANDLE_EINTR(TegraV4L2_Ioctl(device_fd_, flags, arg));
@@ skipping 89 matching lines @@
     uint32_t v4l2_pixfmt,
     const std::vector<base::ScopedFD>& /* dmabuf_fds */) {
   DVLOG(3) << "CreateEGLImage()";
   if (!CanCreateEGLImageFrom(v4l2_pixfmt)) {
     LOG(ERROR) << "Unsupported V4L2 pixel format";
     return EGL_NO_IMAGE_KHR;
   }
 
   EGLint attr = EGL_NONE;
   EGLImageKHR egl_image =
-      eglCreateImageKHR(egl_display,
-                        egl_context,
-                        EGL_GL_TEXTURE_2D_KHR,
-                        reinterpret_cast<EGLClientBuffer>(texture_id),
-                        &attr);
+      eglCreateImageKHR(egl_display, egl_context, EGL_GL_TEXTURE_2D_KHR,
+                        reinterpret_cast<EGLClientBuffer>(texture_id), &attr);
   if (egl_image == EGL_NO_IMAGE_KHR) {
     LOG(ERROR) << "Unable to create EGL image";
     return egl_image;
   }
   if (TegraV4L2_UseEglImage(device_fd_, buffer_index, egl_image) != 0) {
     LOG(ERROR) << "Unable to use EGL image";
     eglDestroyImageKHR(egl_display, egl_image);
     egl_image = EGL_NO_IMAGE_KHR;
   }
   return egl_image;
 }
 
 EGLBoolean TegraV4L2Device::DestroyEGLImage(EGLDisplay egl_display,
                                             EGLImageKHR egl_image) {
   return eglDestroyImageKHR(egl_display, egl_image);
 }
 
-GLenum TegraV4L2Device::GetTextureTarget() { return GL_TEXTURE_2D; }
+GLenum TegraV4L2Device::GetTextureTarget() {
+  return GL_TEXTURE_2D;
+}
 
 uint32_t TegraV4L2Device::PreferredInputFormat() {
   // TODO(posciak): We should support "dontcare" returns here once we
   // implement proper handling (fallback, negotiation) for this in users.
   CHECK_EQ(type_, kEncoder);
   return V4L2_PIX_FMT_YUV420M;
 }
 
-}  //  namespace content
+}  //  namespace media