Limit the number of ARC codec

chrome/gpu/arc_video_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_VIDEO_ACCELERATOR_H_
 #define CHROME_GPU_ARC_VIDEO_ACCELERATOR_H_
 
 #include "base/files/scoped_file.h"
 
 namespace chromeos {
@@ skipping 34 matching lines @@
   uint32_t crop_width = 0;
   uint32_t crop_top = 0;
   uint32_t crop_height = 0;
 };
 
 // The IPC interface between Android and Chromium for video decoding and
 // encoding. Input buffers are sent from Android side and get processed in
 // Chromium and the output buffers are returned back to Android side.
 class ArcVideoAccelerator {
  public:
-  enum Error {
+  enum Result {
+    SUCCESS = 0,
     ILLEGAL_STATE = 1,
     INVALID_ARGUMENT = 2,
     UNREADABLE_INPUT = 3,
     PLATFORM_FAILURE = 4,
+    INSUFFICIENT_RESOURCES = 5,
   };
 
   struct Config {
     enum DeviceType {
       DEVICE_ENCODER = 0,
       DEVICE_DECODER = 1,
     };
 
     DeviceType device_type = DEVICE_DECODER;
     size_t num_input_buffers = 0;
     uint32_t input_pixel_format = 0;
     // TODO(owenlin): Add output_pixel_format. For now only the native pixel
     //                format of each VDA on Chromium is supported.
   };
 
   // The callbacks of the ArcVideoAccelerator. The user of this class should
   // implement this interface.
   class Client {
    public:
     virtual ~Client() {}
 
     // Called when an asynchronous error happens. The errors in Initialize()
-    // will not be reported here, but will be indicated by a false return value
+    // will not be reported here, but will be indicated by a return value
     // there.
-    virtual void OnError(Error error) = 0;
+    virtual void OnError(Result error) = 0;
 
     // Called when a buffer with the specified |index| and |port| has been
     // processed and is no longer used in the accelerator. For input buffers,
     // the Client may fill them with new content. For output buffers, indicates
     // they are ready to be consumed by the client.
     virtual void OnBufferDone(PortType port,
                               uint32_t index,
                               const BufferMetadata& metadata) = 0;
 
     // Called when the output format has changed or the output format
     // becomes available at beginning of the stream after initial parsing.
     virtual void OnOutputFormatChanged(const VideoFormat& format) = 0;
 
     // Called as a completion notification for Reset().
     virtual void OnResetDone() = 0;
 
     // Called as a completion notification for Flush().
     virtual void OnFlushDone() = 0;
   };
 
   // Initializes the ArcVideoAccelerator with specific configuration. This
   // must be called before any other methods. This call is synchronous and
-  // returns true iff initialization is successful.
-  virtual bool Initialize(const Config& config, Client* client) = 0;
+  // returns SUCCESS iff initialization is successful.
+  virtual Result Initialize(const Config& config, Client* client) = 0;
 
   // Assigns a shared memory to be used for the accelerator at the specified
   // port and index. A buffer must be successfully bound before it can be passed
   // to the accelerator via UseBuffer(). Already bound buffers may be reused
   // multiple times without additional bindings.
   virtual void BindSharedMemory(PortType port,
                                 uint32_t index,
                                 base::ScopedFD ashmem_fd,
                                 off_t offset,
                                 size_t length) = 0;
@@ skipping 29 matching lines @@
   // called.
   virtual void Flush() = 0;
 
   virtual ~ArcVideoAccelerator() {}
 };
 
 }  // namespace arc
 }  // namespace chromeos
 
 #endif  // CHROME_GPU_ARC_VIDEO_ACCELERATOR_H_