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"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/gpu/arc_gpu_video_decode_accelerator.h"
 #include "mojo/public/cpp/bindings/type_converter.h"
 #include "mojo/public/cpp/system/platform_handle.h"
 
+// Make sure arc::mojom::VideoAcceleratorService::Result and
+// chromeos::arc::ArcVideoAccelerator::Result match.
+static_assert(
+    static_cast<int>(arc::mojom::VideoAcceleratorService::Result::SUCCESS) ==
+        chromeos::arc::ArcVideoAccelerator::SUCCESS,
+    "enum mismatch");
+static_assert(static_cast<int>(
+                  arc::mojom::VideoAcceleratorService::Result::ILLEGAL_STATE) ==
+                  chromeos::arc::ArcVideoAccelerator::ILLEGAL_STATE,
+              "enum mismatch");
+static_assert(
+    static_cast<int>(
+        arc::mojom::VideoAcceleratorService::Result::INVALID_ARGUMENT) ==
+        chromeos::arc::ArcVideoAccelerator::INVALID_ARGUMENT,
+    "enum mismatch");
+static_assert(
+    static_cast<int>(
+        arc::mojom::VideoAcceleratorService::Result::UNREADABLE_INPUT) ==
+        chromeos::arc::ArcVideoAccelerator::UNREADABLE_INPUT,
+    "enum mismatch");
+static_assert(
+    static_cast<int>(
+        arc::mojom::VideoAcceleratorService::Result::PLATFORM_FAILURE) ==
+        chromeos::arc::ArcVideoAccelerator::PLATFORM_FAILURE,
+    "enum mismatch");
+static_assert(
+    static_cast<int>(
+        arc::mojom::VideoAcceleratorService::Result::INSUFFICIENT_RESOURCES) ==
+        chromeos::arc::ArcVideoAccelerator::INSUFFICIENT_RESOURCES,
+    "enum mismatch");
+
 namespace {
 void OnConnectionError() {
   DVLOG(2) << "OnConnectionError";
 }
 }  // namespace
 
 namespace mojo {
 
 template <>
 struct TypeConverter<arc::mojom::BufferMetadataPtr,
@@ skipping 73 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::SUCCESS);
   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);
+  callback.Run(
+      static_cast<::arc::mojom::VideoAcceleratorService::Result>(result));
+}
+
+void GpuArcVideoService::DeprecatedInitialize(
+    ::arc::mojom::ArcVideoAcceleratorConfigPtr config,
+    const DeprecatedInitializeCallback& callback) {
+  DVLOG(2) << "DeprecatedInitialize";
+  ArcVideoAccelerator::Result result =
+      accelerator_->Initialize(config.To<ArcVideoAccelerator::Config>(), this);
+  callback.Run(result == ArcVideoAccelerator::SUCCESS);
 }
 
 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