Introduce GpuVideoDecodeAcceleratorFactory.

media/video/video_decode_accelerator.h

 // Copyright (c) 2012 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_DECODE_ACCELERATOR_H_
 #define MEDIA_VIDEO_VIDEO_DECODE_ACCELERATOR_H_
 
 #include <stdint.h>
 
 #include <memory>
 #include <vector>
 
+#include "base/memory/ref_counted.h"
+#include "base/memory/weak_ptr.h"
 #include "media/base/bitstream_buffer.h"
 #include "media/base/surface_manager.h"
 #include "media/base/video_decoder_config.h"
 #include "media/video/picture.h"
 #include "ui/gfx/geometry/size.h"
-#include "ui/gl/gl_image.h"
 
 typedef unsigned int GLenum;
 
+namespace base {
+class SingleThreadTaskRunner;
+}
+
 namespace media {
 
 // Video decoder interface.
 // This interface is extended by the various components that ultimately
 // implement the backend of PPB_VideoDecoder_Dev.
 class MEDIA_EXPORT VideoDecodeAccelerator {
  public:
   // Specification of a decoding profile supported by an decoder.
   // |max_resolution| and |min_resolution| are inclusive.
   struct MEDIA_EXPORT SupportedProfile {
     SupportedProfile();
     ~SupportedProfile();
     VideoCodecProfile profile;
     gfx::Size max_resolution;
     gfx::Size min_resolution;
     bool encrypted_only;
   };
   using SupportedProfiles = std::vector<SupportedProfile>;
 
-  using MakeContextCurrentCallback = base::Callback<bool(void)>;
-  using BindImageCallback = base::Callback<
-      void(uint32_t, uint32_t, scoped_refptr<gl::GLImage>, bool)>;
-
   struct MEDIA_EXPORT Capabilities {
     Capabilities();
     Capabilities(const Capabilities& other);
     ~Capabilities();
 
     std::string AsHumanReadableString() const;
 
     // Flags that can be associated with a VDA.
     enum Flags {
       NO_FLAGS = 0,
@@ skipping 167 matching lines @@
   // "seek".
   virtual void Reset() = 0;
 
   // Destroys the decoder: all pending inputs are dropped immediately and the
   // component is freed.  This call may asynchornously free 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;
 
-  // GPU PROCESS ONLY.  Implementations of this interface in the
-  // content/common/gpu/media should implement this, and implementations in
-  // other processes should not override the default implementation.
-  // Returns true if VDA::Decode and VDA::Client callbacks can run on the IO
-  // thread. Otherwise they will run on the GPU child thread. The purpose of
-  // running Decode on the IO thread is to reduce decode latency. Note Decode
-  // should return as soon as possible and not block on the IO thread. Also,
-  // PictureReady should be run on the child thread if a picture is delivered
-  // the first time so it can be cleared.
-  virtual bool CanDecodeOnIOThread();
+  // TO BE CALLED IN THE SAME PROCESS AS THE VDA IMPLEMENTATION ONLY.
+  //
+  // A decode "task" is a sequence that includes a Decode() call from Client,
+  // as well as corresponding callbacks to return the input BitstreamBuffer
+  // after use, and the resulting output Picture(s).
+  //
+  // If the Client can support running these three calls on a separate thread,
+  // it may call this method to try to set up the VDA implementation to do so.
+  // If the VDA can support this as well, return true, otherwise return false.
+  // If true is returned, the client may submit each Decode() call (but no other
+  // calls) on |decode_task_runner|, and should then expect that
+  // NotifyEndOfBitstreamBuffer() and PictureReady() callbacks may come on
+  // |decode_task_runner| as well, called on |decode_client|, instead of client
+  // provided to Initialize().
+  //
+  // This method may be called at any time.
+  //
+  // NOTE 1: some callbacks may still have to come on the main thread and the
+  // Client should handle both callbacks coming on main and |decode_task_runner|
+  // thread.
+  //
+  // NOTE 2: VDA implementations of Decode() must return as soon as possible and
+  // never block, as |decode_task_runner| may be a latency critical thread
+  // (such as the GPU IO thread).
+  //
+  // One application of this is offloading the GPU Child thread. In general,
+  // calls to VDA in GPU process have to be done on the GPU Child thread, as
+  // they may require GL context to be current. However, some VDAs may be able
+  // to run decode operations without GL context, which helps reduce latency and
+  // offloads the GPU Child thread.
+  virtual bool TryToSetupDecodeOnSeparateThread(
+      const base::WeakPtr<Client>& decode_client,
+      const scoped_refptr<base::SingleThreadTaskRunner>& decode_task_runner);
 
   // Windows creates a BGRA texture.
   // TODO(dshwang): after moving to D3D11, remove this. crbug.com/438691
   virtual GLenum GetSurfaceInternalFormat() const;
 
  protected:
   // Do not delete directly; use Destroy() or own it with a scoped_ptr, which
   // will Destroy() it properly by default.
   virtual ~VideoDecodeAccelerator();
 };
 
 }  // namespace media
 
 namespace std {
 
 // Specialize std::default_delete so that scoped_ptr<VideoDecodeAccelerator>
 // uses "Destroy()" instead of trying to use the destructor.
 template <>
 struct MEDIA_EXPORT default_delete<media::VideoDecodeAccelerator> {
   void operator()(media::VideoDecodeAccelerator* vda) const;
 };
 
 }  // namespace std
 
 #endif  // MEDIA_VIDEO_VIDEO_DECODE_ACCELERATOR_H_