Introduce GpuVideoDecodeAcceleratorFactory.

content/common/gpu/media/dxva_video_decode_accelerator_win.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 CONTENT_COMMON_GPU_MEDIA_DXVA_VIDEO_DECODE_ACCELERATOR_H_
 #define CONTENT_COMMON_GPU_MEDIA_DXVA_VIDEO_DECODE_ACCELERATOR_H_
 
 #include <d3d11.h>
 #include <d3d9.h>
 #include <stdint.h>
@@ skipping 11 matching lines @@
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/threading/thread.h"
 #include "base/win/scoped_comptr.h"
 #include "content/common/content_export.h"
+#include "content/common/gpu/media/gpu_video_decode_accelerator_helpers.h"
 #include "media/video/video_decode_accelerator.h"
 
 interface IMFSample;
 interface IDirect3DSurface9;
 
 namespace gfx {
 class GLContext;
 }
 
 typedef HRESULT (WINAPI* CreateDXGIDeviceManager)(
@@ skipping 48 matching lines @@
     kUninitialized,               // un-initialized.
     kNormal,                      // normal playing state.
     kResetting,                   // upon received Reset(), before ResetDone()
     kStopped,                     // upon output EOS received.
     kFlushing,                    // upon flush request received.
     kConfigChange,                // stream configuration change detected.
   };
 
   // Does not take ownership of |client| which must outlive |*this|.
   DXVAVideoDecodeAccelerator(
-      const base::Callback<bool(void)>& make_context_current,
-      gfx::GLContext* gl_context,
+      const GetGLContextCallback& get_gl_context_cb,
+      const MakeGLContextCurrentCallback& make_context_current_cb,
       bool enable_accelerated_vpx_decode);
   ~DXVAVideoDecodeAccelerator() override;
 
   // media::VideoDecodeAccelerator implementation.
   bool Initialize(const Config& config, Client* client) override;
   void Decode(const media::BitstreamBuffer& bitstream_buffer) override;
   void AssignPictureBuffers(
       const std::vector<media::PictureBuffer>& buffers) override;
   void ReusePictureBuffer(int32_t picture_buffer_id) override;
   void Flush() override;
   void Reset() override;
   void Destroy() override;
-  bool CanDecodeOnIOThread() override;
+  bool TryToSetupDecodeOnSeparateThread(
+      const base::WeakPtr<Client>& decode_client,
+      const scoped_refptr<base::SingleThreadTaskRunner>& decode_task_runner)
+      override;
   GLenum GetSurfaceInternalFormat() const override;
 
   static media::VideoDecodeAccelerator::SupportedProfiles
       GetSupportedProfiles();
 
   // Preload dlls required for decoding.
   static void PreSandboxInitialization();
 
  private:
   typedef void* EGLConfig;
@@ skipping 259 matching lines @@
 
   // Set to true when the drain message is sent to the decoder during a flush
   // operation. Used to ensure the message is only sent once after
   // |pending_input_buffers_| is drained. Protected by |decoder_lock_|.
   bool sent_drain_message_;
 
   // List of input samples waiting to be processed.
   typedef std::list<base::win::ScopedComPtr<IMFSample>> PendingInputs;
   PendingInputs pending_input_buffers_;
 
+  // Callback to get current GLContext.
+  GetGLContextCallback get_gl_context_cb_;
   // Callback to set the correct gl context.
-  base::Callback<bool(void)> make_context_current_;
+  MakeGLContextCurrentCallback make_context_current_cb_;
 
   // Which codec we are decoding with hardware acceleration.
   media::VideoCodec codec_;
   // Thread on which the decoder operations like passing input frames,
   // getting output frames are performed. One instance of this thread
   // is created per decoder instance.
   base::Thread decoder_thread_;
 
   // Task runner to be used for posting tasks to the decoder thread.
   scoped_refptr<base::SingleThreadTaskRunner> decoder_thread_task_runner_;
@@ skipping 19 matching lines @@
   bool use_dx11_;
 
   // True if we should use DXGI keyed mutexes to synchronize between the two
   // contexts.
   bool use_keyed_mutex_;
 
   // Set to true if the DX11 video format converter input media types need to
   // be initialized. Defaults to true.
   bool dx11_video_format_converter_media_type_needs_init_;
 
-  // The GLContext to be used by the decoder.
-  scoped_refptr<gfx::GLContext> gl_context_;
-
   // Set to true if we are sharing ANGLE's device.
   bool using_angle_device_;
 
   // Enables experimental hardware acceleration for VP8/VP9 video decoding.
   const bool enable_accelerated_vpx_decode_;
 
   // The media foundation H.264 decoder has problems handling changes like
   // resolution change, bitrate change etc. If we reinitialize the decoder
   // when these changes occur then, the decoder works fine. The
   // H264ConfigChangeDetector class provides functionality to check if the
   // stream configuration changed.
   H264ConfigChangeDetector config_change_detector_;
 
   // Contains the initialization parameters for the video.
   Config config_;
 
   // WeakPtrFactory for posting tasks back to |this|.
   base::WeakPtrFactory<DXVAVideoDecodeAccelerator> weak_this_factory_;
 
   // Function pointer for the MFCreateDXGIDeviceManager API.
   static CreateDXGIDeviceManager create_dxgi_device_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(DXVAVideoDecodeAccelerator);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_MEDIA_DXVA_VIDEO_DECODE_ACCELERATOR_H_