ArcBridge: Rename VideoAcceleratorService to VideoDecodeAccelerator.

chrome/gpu/arc_gpu_video_decode_accelerator.cc

 // 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.
 
 #include "chrome/gpu/arc_gpu_video_decode_accelerator.h"
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/numerics/safe_math.h"
@@ skipping 51 matching lines @@
       requested_num_of_output_buffers_(0),
       gpu_preferences_(gpu_preferences) {}
 
 ArcGpuVideoDecodeAccelerator::~ArcGpuVideoDecodeAccelerator() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (vda_) {
     client_count_--;
   }
 }
 
-ArcVideoAccelerator::Result ArcGpuVideoDecodeAccelerator::Initialize(
+ArcVideoDecodeAccelerator::Result ArcGpuVideoDecodeAccelerator::Initialize(
     const Config& config,
-    ArcVideoAccelerator::Client* client) {
+    ArcVideoDecodeAccelerator::Client* client) {
   auto result = InitializeTask(config, client);
   // Report initialization status to UMA.
   UMA_HISTOGRAM_ENUMERATION(
       "Media.ArcGpuVideoDecodeAccelerator.InitializeResult", result,
       RESULT_MAX);
   return result;
 }
 
-ArcVideoAccelerator::Result ArcGpuVideoDecodeAccelerator::InitializeTask(
+ArcVideoDecodeAccelerator::Result ArcGpuVideoDecodeAccelerator::InitializeTask(
     const Config& config,
-    ArcVideoAccelerator::Client* client) {
-  DVLOG(5) << "Initialize(device=" << config.device_type
-           << ", input_pixel_format=" << config.input_pixel_format
+    ArcVideoDecodeAccelerator::Client* client) {
+  DVLOG(5) << "Initialize(input_pixel_format=" << config.input_pixel_format
            << ", num_input_buffers=" << config.num_input_buffers << ")";
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (config.device_type != Config::DEVICE_DECODER)
-    return INVALID_ARGUMENT;
   DCHECK(client);
 
   if (arc_client_) {
     DLOG(ERROR) << "Re-Initialize() is not allowed";
     return ILLEGAL_STATE;
   }
 
   if (client_count_ >= kMaxConcurrentClients) {
     LOG(WARNING) << "Reject to Initialize() due to too many clients: "
                  << client_count_;
@@ skipping 28 matching lines @@
 
   auto vda_factory = media::GpuVideoDecodeAcceleratorFactory::CreateWithNoGL();
   vda_ = vda_factory->CreateVDA(
       this, vda_config, gpu::GpuDriverBugWorkarounds(), gpu_preferences_);
   if (!vda_) {
     DLOG(ERROR) << "Failed to create VDA.";
     return PLATFORM_FAILURE;
   }
 
   client_count_++;
-  DVLOG(5) << "Number of concurrent ArcVideoAccelerator clients: "
+  DVLOG(5) << "Number of concurrent ArcVideoDecodeAccelerator clients: "
            << client_count_;
 
   return SUCCESS;
 }
 
 void ArcGpuVideoDecodeAccelerator::SetNumberOfOutputBuffers(size_t number) {
   DVLOG(5) << "SetNumberOfOutputBuffers(" << number << ")";
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!vda_) {
     DLOG(ERROR) << "VDA not initialized";
@@ skipping 307 matching lines @@
 void ArcGpuVideoDecodeAccelerator::NotifyFlushDone() {
   DCHECK(thread_checker_.CalledOnValidThread());
   arc_client_->OnFlushDone();
 }
 
 void ArcGpuVideoDecodeAccelerator::NotifyResetDone() {
   DCHECK(thread_checker_.CalledOnValidThread());
   arc_client_->OnResetDone();
 }
 
-static ArcVideoAccelerator::Result ConvertErrorCode(
+static ArcVideoDecodeAccelerator::Result ConvertErrorCode(
     media::VideoDecodeAccelerator::Error error) {
   switch (error) {
     case media::VideoDecodeAccelerator::ILLEGAL_STATE:
-      return ArcVideoAccelerator::ILLEGAL_STATE;
+      return ArcVideoDecodeAccelerator::ILLEGAL_STATE;
     case media::VideoDecodeAccelerator::INVALID_ARGUMENT:
-      return ArcVideoAccelerator::INVALID_ARGUMENT;
+      return ArcVideoDecodeAccelerator::INVALID_ARGUMENT;
     case media::VideoDecodeAccelerator::UNREADABLE_INPUT:
-      return ArcVideoAccelerator::UNREADABLE_INPUT;
+      return ArcVideoDecodeAccelerator::UNREADABLE_INPUT;
     case media::VideoDecodeAccelerator::PLATFORM_FAILURE:
-      return ArcVideoAccelerator::PLATFORM_FAILURE;
+      return ArcVideoDecodeAccelerator::PLATFORM_FAILURE;
     default:
       DLOG(ERROR) << "Unknown error: " << error;
-      return ArcVideoAccelerator::PLATFORM_FAILURE;
+      return ArcVideoDecodeAccelerator::PLATFORM_FAILURE;
   }
 }
 
 void ArcGpuVideoDecodeAccelerator::NotifyError(
     media::VideoDecodeAccelerator::Error error) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DLOG(ERROR) << "Error notified: " << error;
   arc_client_->OnError(ConvertErrorCode(error));
 }
 
@@ skipping 39 matching lines @@
       }
       return true;
     default:
       DLOG(ERROR) << "Invalid port: " << port;
       return false;
   }
 }
 
 }  // namespace arc
 }  // namespace chromeos