Test X11 header pollution

media/gpu/ipc/service/gpu_jpeg_decode_accelerator.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 "content/common/gpu/media/gpu_jpeg_decode_accelerator.h"
+#include "media/gpu/ipc/service/gpu_jpeg_decode_accelerator.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
 #include "base/logging.h"
 #include "base/memory/shared_memory.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "gpu/ipc/service/gpu_channel.h"
 #include "ipc/ipc_message_macros.h"
 #include "ipc/message_filter.h"
 #include "media/filters/jpeg_parser.h"
 #include "media/gpu/ipc/common/media_messages.h"
 #include "ui/gfx/geometry/size.h"
 
 #if defined(OS_CHROMEOS)
 #if defined(ARCH_CPU_X86_FAMILY)
-#include "content/common/gpu/media/vaapi_jpeg_decode_accelerator.h"
+#include "media/gpu/vaapi_jpeg_decode_accelerator.h"
 #endif
 #if defined(USE_V4L2_CODEC)
-#include "content/common/gpu/media/v4l2_device.h"
-#include "content/common/gpu/media/v4l2_jpeg_decode_accelerator.h"
+#include "media/gpu/v4l2_device.h"
+#include "media/gpu/v4l2_jpeg_decode_accelerator.h"
 #endif
 #endif
 
 namespace {
 
 void DecodeFinished(std::unique_ptr<base::SharedMemory> shm) {
   // Do nothing. Because VideoFrame is backed by |shm|, the purpose of this
   // function is to just keep reference of |shm| to make sure it lives util
   // decode finishes.
 }
@@ skipping 18 matching lines @@
     LOG(ERROR) << "output_buffer_size is too small: "
                << params.output_buffer_size;
     return false;
   }
 
   return true;
 }
 
 }  // namespace
 
-namespace content {
+namespace media {
 
 class GpuJpegDecodeAccelerator::Client
     : public media::JpegDecodeAccelerator::Client,
       public base::NonThreadSafe {
  public:
-  Client(content::GpuJpegDecodeAccelerator* owner, int32_t route_id)
+  Client(media::GpuJpegDecodeAccelerator* owner, int32_t route_id)
       : owner_(owner->AsWeakPtr()), route_id_(route_id) {}
 
   ~Client() override { DCHECK(CalledOnValidThread()); }
 
   // media::JpegDecodeAccelerator::Client implementation.
   void VideoFrameReady(int32_t bitstream_buffer_id) override {
     DCHECK(CalledOnValidThread());
     if (owner_)
       owner_->NotifyDecodeStatus(route_id_, bitstream_buffer_id,
                                  media::JpegDecodeAccelerator::NO_ERRORS);
@@ skipping 13 matching lines @@
     accelerator_->Decode(bitstream_buffer, video_frame);
   }
 
   void set_accelerator(
       std::unique_ptr<media::JpegDecodeAccelerator> accelerator) {
     DCHECK(CalledOnValidThread());
     accelerator_ = std::move(accelerator);
   }
 
  private:
-  base::WeakPtr<content::GpuJpegDecodeAccelerator> owner_;
+  base::WeakPtr<media::GpuJpegDecodeAccelerator> owner_;
   int32_t route_id_;
   std::unique_ptr<media::JpegDecodeAccelerator> accelerator_;
 };
 
 // Create, destroy, and RemoveClient run on child thread. All other methods run
 // on IO thread.
 class GpuJpegDecodeAccelerator::MessageFilter : public IPC::MessageFilter {
  public:
   explicit MessageFilter(GpuJpegDecodeAccelerator* owner)
       : owner_(owner->AsWeakPtr()),
@@ skipping 170 matching lines @@
   // only be accessed on IO thread.
   ClientMap client_map_;
 };
 
 GpuJpegDecodeAccelerator::GpuJpegDecodeAccelerator(
     gpu::GpuChannel* channel,
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
     : channel_(channel),
       child_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       io_task_runner_(io_task_runner),
-      client_number_(0) {
-}
+      client_number_(0) {}
 
 GpuJpegDecodeAccelerator::~GpuJpegDecodeAccelerator() {
   DCHECK(CalledOnValidThread());
   if (filter_) {
     channel_->RemoveFilter(filter_.get());
   }
 }
 
 void GpuJpegDecodeAccelerator::AddClient(int32_t route_id,
                                          base::Callback<void(bool)> response) {
@@ skipping 67 matching lines @@
   DCHECK(CalledOnValidThread());
   return channel_->Send(message);
 }
 
 // static
 std::unique_ptr<media::JpegDecodeAccelerator>
 GpuJpegDecodeAccelerator::CreateV4L2JDA(
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner) {
   std::unique_ptr<media::JpegDecodeAccelerator> decoder;
 #if defined(OS_CHROMEOS) && defined(USE_V4L2_CODEC)
-  scoped_refptr<V4L2Device> device = V4L2Device::Create(
-      V4L2Device::kJpegDecoder);
+  scoped_refptr<V4L2Device> device =
+      V4L2Device::Create(V4L2Device::kJpegDecoder);
   if (device)
     decoder.reset(new V4L2JpegDecodeAccelerator(device, io_task_runner));
 #endif
   return decoder;
 }
 
 // static
 std::unique_ptr<media::JpegDecodeAccelerator>
 GpuJpegDecodeAccelerator::CreateVaapiJDA(
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner) {
@@ skipping 12 matching lines @@
   };
   for (const auto& create_jda_function : create_jda_fps) {
     std::unique_ptr<media::JpegDecodeAccelerator> accelerator =
         (*create_jda_function)(base::ThreadTaskRunnerHandle::Get());
     if (accelerator && accelerator->IsSupported())
       return true;
   }
   return false;
 }
 
-}  // namespace content
+}  // namespace media