Test X11 header pollution

media/gpu/v4l2_image_processor.h

 // 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.
 
-#ifndef CONTENT_COMMON_GPU_MEDIA_V4L2_IMAGE_PROCESSOR_H_
-#define CONTENT_COMMON_GPU_MEDIA_V4L2_IMAGE_PROCESSOR_H_
+#ifndef MEDIA_GPU_V4L2_IMAGE_PROCESSOR_H_
+#define MEDIA_GPU_V4L2_IMAGE_PROCESSOR_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <queue>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread.h"
-#include "content/common/content_export.h"
-#include "content/common/gpu/media/v4l2_device.h"
 #include "media/base/video_frame.h"
+#include "media/gpu/media_gpu_export.h"
+#include "media/gpu/v4l2_device.h"
 
-namespace content {
+namespace media {
 
 // Handles image processing accelerators that expose a V4L2 memory-to-memory
 // interface. The threading model of this class is the same as for other V4L2
 // hardware accelerators (see V4L2VideoDecodeAccelerator) for more details.
-class CONTENT_EXPORT V4L2ImageProcessor {
+class MEDIA_GPU_EXPORT V4L2ImageProcessor {
  public:
   explicit V4L2ImageProcessor(const scoped_refptr<V4L2Device>& device);
   virtual ~V4L2ImageProcessor();
 
   // Initializes the processor to convert from |input_format| to |output_format|
   // and/or scale from |input_visible_size| to |output_visible_size|.
   // Request the input buffers to be of at least |input_allocated_size| and the
   // output buffers to be of at least |output_allocated_size|. The number of
   // input buffers and output buffers will be |num_buffers|. Provided |error_cb|
   // will be called if an error occurs. Return true if the requested
@@ skipping 133 matching lines @@
   // V4L2 device in use.
   scoped_refptr<V4L2Device> device_;
 
   // Thread to communicate with the device on.
   base::Thread device_thread_;
   // Thread used to poll the V4L2 for events only.
   base::Thread device_poll_thread_;
 
   // All the below members are to be accessed from device_thread_ only
   // (if it's running).
-  std::queue<linked_ptr<JobRecord> > input_queue_;
-  std::queue<linked_ptr<JobRecord> > running_jobs_;
+  std::queue<linked_ptr<JobRecord>> input_queue_;
+  std::queue<linked_ptr<JobRecord>> running_jobs_;
 
   // Input queue state.
   bool input_streamon_;
   // Number of input buffers enqueued to the device.
   int input_buffer_queued_count_;
   // Input buffers ready to use; LIFO since we don't care about ordering.
   std::vector<int> free_input_buffers_;
   // Mapping of int index to an input buffer record.
   std::vector<InputRecord> input_buffer_map_;
 
@@ skipping 16 matching lines @@
   // thread to the device thread should use base::Unretained(this),
   // and tasks posted the other way should use |weak_this_|.
   base::WeakPtr<V4L2ImageProcessor> weak_this_;
 
   // Weak factory for producing weak pointers on the child thread.
   base::WeakPtrFactory<V4L2ImageProcessor> weak_this_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(V4L2ImageProcessor);
 };
 
-}  // namespace content
+}  // namespace media
 
-#endif  // CONTENT_COMMON_GPU_MEDIA_V4L2_IMAGE_PROCESSOR_H_
+#endif  // MEDIA_GPU_V4L2_IMAGE_PROCESSOR_H_