Move video encode accelerator IPC messages to GPU IO thread

media/video/video_encode_accelerator.h

 // Copyright 2013 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 MEDIA_VIDEO_VIDEO_ENCODE_ACCELERATOR_H_
 #define MEDIA_VIDEO_VIDEO_ENCODE_ACCELERATOR_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <vector>
 
 #include "base/memory/ref_counted.h"
+#include "base/memory/weak_ptr.h"
+#include "base/single_thread_task_runner.h"
 #include "media/base/bitstream_buffer.h"
 #include "media/base/media_export.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_frame.h"
 
 namespace media {
 
 class BitstreamBuffer;
 class VideoFrame;
 
@@ skipping 115 matching lines @@
   // Request a change to the encoding parameters.  This is only a request,
   // fulfilled on a best-effort basis.
   // Parameters:
   //  |bitrate| is the requested new bitrate, in bits per second.
   //  |framerate| is the requested new framerate, in frames per second.
   virtual void RequestEncodingParametersChange(uint32_t bitrate,
                                                uint32_t framerate) = 0;
 
   // Destroys the encoder: all pending inputs and outputs are dropped
   // immediately and the component is freed.  This call may asynchronously free
-  // system resources, but its client-visible effects are synchronous.  After
-  // this method returns no more callbacks will be made on the client.  Deletes
+  // system resources, but its client-visible effects are synchronous. After
+  // this method returns no more callbacks will be made on the client. Deletes
   // |this| unconditionally, so make sure to drop all pointers to it!
   virtual void Destroy() = 0;
 
+  // Encode tasks include these methods that are used frequently during the
+  // session: Encode(), UseOutputBitstreamBuffer(),
+  // RequestEncodingParametersChange(), Client::BitstreamBufferReady().
+  // If the Client can support running these on a separate thread, it may
+  // call this method to try to set up the VEA implementation to do so.
+  //
+  // If the VEA can support this as well, return true, otherwise return false.
+  // If true is returned, the client may submit each of these calls on
+  // |encode_task_runner|, and then expect Client::BitstreamBufferReady() to be
+  // called on |encode_task_runner| as well; called on |encode_client|, instead
+  // of |client| provided to Initialize().
+  //
+  // One application of this is offloading the GPU main thread. This helps
+  // reduce latency and jitter by avoiding the wait.
+  virtual bool TryToSetupEncodeOnSeparateThread(
+      const base::WeakPtr<Client>& encode_client,
+      const scoped_refptr<base::SingleThreadTaskRunner>& encode_task_runner);
+
  protected:
   // Do not delete directly; use Destroy() or own it with a scoped_ptr, which
   // will Destroy() it properly by default.
   virtual ~VideoEncodeAccelerator();
 };
 
 }  // namespace media
 
 namespace std {
 
 // Specialize std::default_delete so that
 // std::unique_ptr<VideoEncodeAccelerator> uses "Destroy()" instead of trying to
 // use the destructor.
 template <>
 struct MEDIA_EXPORT default_delete<media::VideoEncodeAccelerator> {
   void operator()(media::VideoEncodeAccelerator* vea) const;
 };
 
 }  // namespace std
 
 #endif  // MEDIA_VIDEO_VIDEO_ENCODE_ACCELERATOR_H_