ArcBridge: Rename VideoAcceleratorService to VideoDecodeAccelerator.

chrome/gpu/chrome_arc_video_decode_accelerator.h

 // Copyright 2016 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 CHROME_GPU_ARC_GPU_VIDEO_DECODE_ACCELERATOR_H_
-#define CHROME_GPU_ARC_GPU_VIDEO_DECODE_ACCELERATOR_H_
+#ifndef CHROME_GPU_CHROME_ARC_VIDEO_DECODE_ACCELERATOR_H_
+#define CHROME_GPU_CHROME_ARC_VIDEO_DECODE_ACCELERATOR_H_
 
 #include <list>
 #include <memory>
 #include <queue>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/threading/thread_checker.h"
-#include "chrome/gpu/arc_video_accelerator.h"
+#include "chrome/gpu/arc_video_decode_accelerator.h"
 #include "gpu/command_buffer/service/gpu_preferences.h"
 #include "media/video/video_decode_accelerator.h"
 
 namespace chromeos {
 namespace arc {
 
 // This class is executed in the GPU process. It takes decoding requests from
 // ARC via IPC channels and translates and sends those requests to an
 // implementation of media::VideoDecodeAccelerator. It also returns the decoded
 // frames back to the ARC side.
-class ArcGpuVideoDecodeAccelerator
-    : public ArcVideoAccelerator,
+class ChromeArcVideoDecodeAccelerator
+    : public ArcVideoDecodeAccelerator,
       public media::VideoDecodeAccelerator::Client,
-      public base::SupportsWeakPtr<ArcGpuVideoDecodeAccelerator> {
+      public base::SupportsWeakPtr<ChromeArcVideoDecodeAccelerator> {
  public:
-  explicit ArcGpuVideoDecodeAccelerator(
+  explicit ChromeArcVideoDecodeAccelerator(
       const gpu::GpuPreferences& gpu_preferences);
-  ~ArcGpuVideoDecodeAccelerator() override;
+  ~ChromeArcVideoDecodeAccelerator() override;
 
-  // Implementation of the ArcVideoAccelerator interface.
-  ArcVideoAccelerator::Result Initialize(
+  // Implementation of the ArcVideoDecodeAccelerator interface.
+  ArcVideoDecodeAccelerator::Result Initialize(
       const Config& config,
-      ArcVideoAccelerator::Client* client) override;
+      ArcVideoDecodeAccelerator::Client* client) override;
   void SetNumberOfOutputBuffers(size_t number) override;
   void BindSharedMemory(PortType port,
                         uint32_t index,
                         base::ScopedFD ashmem_fd,
                         off_t offset,
                         size_t length) override;
   void BindDmabuf(PortType port,
                   uint32_t index,
                   base::ScopedFD dmabuf_fd,
                   const std::vector<::arc::ArcVideoAcceleratorDmabufPlane>&
@@ skipping 51 matching lines @@
   struct OutputBufferInfo {
     base::ScopedFD handle;
     std::vector<::arc::ArcVideoAcceleratorDmabufPlane> planes;
 
     OutputBufferInfo();
     OutputBufferInfo(OutputBufferInfo&& other);
     ~OutputBufferInfo();
   };
 
   // The helper method to simplify reporting of the status returned to UMA.
-  ArcVideoAccelerator::Result InitializeTask(
+  ArcVideoDecodeAccelerator::Result InitializeTask(
       const Config& config,
-      ArcVideoAccelerator::Client* client);
+      ArcVideoDecodeAccelerator::Client* client);
 
   // Helper function to validate |port| and |index|.
   bool ValidatePortAndIndex(PortType port, uint32_t index) const;
 
   // Return true if |dmabuf_planes| is valid for a dmabuf |fd|.
   bool VerifyDmabuf(const base::ScopedFD& fd,
                     const std::vector<::arc::ArcVideoAcceleratorDmabufPlane>&
                         dmabuf_planes) const;
 
   // Creates an InputRecord for the given |bitstream_buffer_id|. The
@@ skipping 12 matching lines @@
 
   // Global counter that keeps track the number of active clients (i.e., how
   // many VDAs in use by this class).
   // Since this class only works on the same thread, it's safe to access
   // |client_count_| without lock.
   static int client_count_;
 
   std::unique_ptr<media::VideoDecodeAccelerator> vda_;
 
   // It's safe to use the pointer here, the life cycle of the |arc_client_|
-  // is longer than this ArcGpuVideoDecodeAccelerator.
-  ArcVideoAccelerator::Client* arc_client_;
+  // is longer than this ChromeArcVideoDecodeAccelerator.
+  ArcVideoDecodeAccelerator::Client* arc_client_;
 
   // The next ID for the bitstream buffer, started from 0.
   int32_t next_bitstream_buffer_id_;
 
   gfx::Size coded_size_;
   gfx::Rect visible_rect_;
   media::VideoPixelFormat output_pixel_format_;
 
   // A list of most recent |kMaxNumberOfInputRecord| InputRecords.
   // |kMaxNumberOfInputRecord| is defined in the cc file.
   std::list<InputRecord> input_records_;
 
   // The details of the shared memory of each input buffers.
   std::vector<InputBufferInfo> input_buffer_info_;
 
   // To keep those output buffers which have been bound by bindDmabuf() but
   // haven't been passed to VDA yet. Will call VDA::ImportBufferForPicture()
   // when those buffers are used for the first time.
   std::vector<OutputBufferInfo> buffers_pending_import_;
 
-  base::ThreadChecker thread_checker_;
+  THREAD_CHECKER(thread_checker_);
   size_t output_buffer_size_;
 
   // The minimal number of requested output buffers.
   uint32_t requested_num_of_output_buffers_;
 
   gpu::GpuPreferences gpu_preferences_;
 
-  DISALLOW_COPY_AND_ASSIGN(ArcGpuVideoDecodeAccelerator);
+  DISALLOW_COPY_AND_ASSIGN(ChromeArcVideoDecodeAccelerator);
 };
 
 }  // namespace arc
 }  // namespace chromeos
 
-#endif  // CHROME_GPU_ARC_GPU_VIDEO_DECODE_ACCELERATOR_H_
+#endif  // CHROME_GPU_CHROME_ARC_VIDEO_DECODE_ACCELERATOR_H_