Limit the number of ARC codec

chrome/gpu/gpu_arc_video_service.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/gpu_arc_video_service.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 88 matching lines @@
 
   accelerator_.reset(new ArcGpuVideoDecodeAccelerator());
 
   ::arc::mojom::VideoAcceleratorServicePtr service;
   binding_.Bind(GetProxy(&service));
   binding_.set_connection_error_handler(base::Bind(&OnConnectionError));
 
   client_->Init(std::move(service));
 }
 
-void GpuArcVideoService::OnError(ArcVideoAccelerator::Error error) {
+void GpuArcVideoService::OnError(ArcVideoAccelerator::Result error) {
   DVLOG(2) << "OnError " << error;
+  DCHECK_NE(error, ArcVideoAccelerator::NO_ERROR);
   client_->OnError(
-      static_cast<::arc::mojom::VideoAcceleratorServiceClient::Error>(error));
+      static_cast<::arc::mojom::VideoAcceleratorService::Result>(error));
 }
 
 void GpuArcVideoService::OnBufferDone(PortType port,
                                       uint32_t index,
                                       const BufferMetadata& metadata) {
   DVLOG(2) << "OnBufferDone " << port << "," << index;
   client_->OnBufferDone(static_cast<::arc::mojom::PortType>(port), index,
                         ::arc::mojom::BufferMetadata::From(metadata));
 }
 
 void GpuArcVideoService::OnFlushDone() {
   DVLOG(2) << "OnFlushDone";
   client_->OnFlushDone();
 }
 
 void GpuArcVideoService::OnResetDone() {
   DVLOG(2) << "OnResetDone";
   client_->OnResetDone();
 }
 
 void GpuArcVideoService::OnOutputFormatChanged(const VideoFormat& format) {
   DVLOG(2) << "OnOutputFormatChanged";
   client_->OnOutputFormatChanged(::arc::mojom::VideoFormat::From(format));
 }
 
 void GpuArcVideoService::Initialize(
     ::arc::mojom::ArcVideoAcceleratorConfigPtr config,
     const InitializeCallback& callback) {
   DVLOG(2) << "Initialize";
-  bool result =
+  ArcVideoAccelerator::Result result =
       accelerator_->Initialize(config.To<ArcVideoAccelerator::Config>(), this);
-  callback.Run(result);
+  if (result == ArcVideoAccelerator::NO_ERROR) {
+    callback.Run(true, ::arc::mojom::VideoAcceleratorService::Result::NO_ERROR);
+  } else {
+    callback.Run(
+        false,
+        static_cast<::arc::mojom::VideoAcceleratorService::Result>(result));
+  }
 }
 
 base::ScopedFD GpuArcVideoService::UnwrapFdFromMojoHandle(
     mojo::ScopedHandle handle) {
   if (!handle.is_valid()) {
     LOG(ERROR) << "handle is invalid";
     client_->OnError(
-        ::arc::mojom::VideoAcceleratorServiceClient::Error::INVALID_ARGUMENT);
+        ::arc::mojom::VideoAcceleratorService::Result::INVALID_ARGUMENT);
     return base::ScopedFD();
   }
 
   base::PlatformFile platform_file;
   MojoResult mojo_result =
       mojo::UnwrapPlatformFile(std::move(handle), &platform_file);
   if (mojo_result != MOJO_RESULT_OK) {
     LOG(ERROR) << "UnwrapPlatformFile failed: " << mojo_result;
     client_->OnError(
-        ::arc::mojom::VideoAcceleratorServiceClient::Error::PLATFORM_FAILURE);
+        ::arc::mojom::VideoAcceleratorService::Result::PLATFORM_FAILURE);
     return base::ScopedFD();
   }
 
   return base::ScopedFD(platform_file);
 }
 
 void GpuArcVideoService::BindSharedMemory(::arc::mojom::PortType port,
                                           uint32_t index,
                                           mojo::ScopedHandle ashmem_handle,
                                           uint32_t offset,
@@ skipping 39 matching lines @@
   accelerator_->Reset();
 }
 
 void GpuArcVideoService::Flush() {
   DVLOG(2) << "Flush";
   accelerator_->Flush();
 }
 
 }  // namespace arc
 }  // namespace chromeos