src/ui/surface/accelerated_surface_win.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef UI_SURFACE_ACCELERATED_SURFACE_WIN_H_
   6 #define UI_SURFACE_ACCELERATED_SURFACE_WIN_H_
   7
   8 #include <d3d9.h>
   9
  10 #include "base/callback_forward.h"
  11 #include "base/memory/ref_counted.h"
  12 #include "base/single_thread_task_runner.h"
  13 #include "base/synchronization/lock.h"
  14 #include "base/synchronization/waitable_event.h"
  15 #include "base/time/time.h"
  16 #include "base/win/scoped_comptr.h"
  17 #include "ui/events/latency_info.h"
  18 #include "ui/gfx/native_widget_types.h"
  19 #include "ui/gfx/size.h"
  20 #include "ui/surface/surface_export.h"
  21
  22 class PresentThread;
  23
  24 namespace gfx {
  25 class Rect;
  26 }
  27
  28 namespace media {
  29 class VideoFrame;
  30 }
  31
  32 class SURFACE_EXPORT AcceleratedPresenter
  33     : public base::RefCountedThreadSafe<AcceleratedPresenter> {
  34  public:
  35   typedef base::Callback<void(bool,
  36                               base::TimeTicks,
  37                               base::TimeDelta,
  38                               const ui::LatencyInfo&)> CompletionTask;
  39
  40   explicit AcceleratedPresenter(gfx::PluginWindowHandle window);
  41
  42   static void SetAdapterLUID(uint64 adapter_luid);
  43
  44   // Returns a thread safe reference to the presenter for the given window or
  45   // null is no such presenter exists. The thread safe refptr ensures the
  46   // presenter will not be destroyed. This can be called on any thread.
  47   static scoped_refptr<AcceleratedPresenter> GetForWindow(
  48       gfx::PluginWindowHandle window);
  49
  50   // Schedule a frame to be presented. The completion callback will be invoked
  51   // when it is safe to write to the surface on another thread. The lock for
  52   // this surface will be held while the completion callback runs. This can be
  53   // called on any thread.
  54   void AsyncPresentAndAcknowledge(
  55       const gfx::Size& size,
  56       int64 surface_handle,
  57       const ui::LatencyInfo& latency_info,
  58       const CompletionTask& completion_task);
  59
  60   // Returns true if the swap chain has been created and initialized.  This can
  61   // be called on any thread.
  62   bool IsSwapChainInitialized() const;
  63
  64   // Schedule the presenter to free all its resources. This can be called on any
  65   // thread.
  66   void Suspend();
  67
  68   // Indicates that the presenter has become invisible.
  69   void WasHidden();
  70
  71   // Called when the Windows session is locked or unlocked.
  72   void SetIsSessionLocked(bool locked);
  73
  74   // Schedule the presenter to release its reference to the shared surface.
  75   void ReleaseSurface();
  76
  77   // The public member functions are called on the main thread.
  78   void Present(HDC dc);
  79   void AsyncCopyTo(const gfx::Rect& src_subrect,
  80                    const gfx::Size& dst_size,
  81                    const base::Callback<void(bool, const SkBitmap&)>& callback);
  82   void AsyncCopyToVideoFrame(
  83       const gfx::Rect& src_subrect,
  84       const scoped_refptr<media::VideoFrame>& target,
  85       const base::Callback<void(bool)>& callback);
  86   void Invalidate();
  87
  88   // Destroy any D3D resources owned by the given present thread. Called on
  89   // the given present thread.
  90   void ResetPresentThread(PresentThread* present_thread);
  91
  92  private:
  93   friend class base::RefCountedThreadSafe<AcceleratedPresenter>;
  94
  95   ~AcceleratedPresenter();
  96
  97   // These member functions are called on the PresentThread with which the
  98   // presenter has affinity.
  99   void DoPresentAndAcknowledge(
 100       const gfx::Size& size,
 101       int64 surface_handle,
 102       const ui::LatencyInfo& latency_info,
 103       const CompletionTask& completion_task);
 104   void DoSuspend();
 105   void DoPresent(const base::Closure& composite_task);
 106   void DoReleaseSurface();
 107   void DoCopyToAndAcknowledge(
 108       const gfx::Rect& src_subrect,
 109       const gfx::Size& dst_size,
 110       scoped_refptr<base::SingleThreadTaskRunner> callback_runner,
 111       const base::Callback<void(bool, const SkBitmap&)>& callback);
 112   void DoCopyToVideoFrameAndAcknowledge(
 113       const gfx::Rect& src_subrect,
 114       const scoped_refptr<media::VideoFrame>& target,
 115       const scoped_refptr<base::SingleThreadTaskRunner>& callback_runner,
 116       const base::Callback<void(bool)>& callback);
 117   bool DoCopyToYUV(const gfx::Rect& src_subrect,
 118                    const scoped_refptr<media::VideoFrame>& frame);
 119   bool DoCopyToARGB(const gfx::Rect& src_subrect,
 120                     const gfx::Size& dst_size,
 121                     SkBitmap* bitmap);
 122
 123   void PresentWithGDI(HDC dc);
 124   gfx::Size GetWindowSize();
 125
 126   // This function tries to guess whether Direct3D will be able to reliably
 127   // present to the window. When the window is resizing, presenting with
 128   // Direct3D causes other regions of the window rendered with GDI to
 129   // flicker transparent / non-transparent.
 130   bool CheckDirect3DWillWork();
 131
 132   // The thread with which this presenter has affinity.
 133   PresentThread* const present_thread_;
 134
 135   // The window that is presented to.
 136   gfx::PluginWindowHandle window_;
 137
 138   // UI thread can wait on this event to ensure a present is finished.
 139   base::WaitableEvent event_;
 140
 141   // The current size of the swap chain. This is only accessed on the thread
 142   // with which the surface has affinity. The swap chain size is rounded up and
 143   // is not necessarily the same as the window size.
 144   gfx::Size quantized_size_;
 145
 146   // The size of the window on the last present. This is used to trigger the
 147   // compositor instead of presenting the last frame in the case where the
 148   // window has been resized.
 149   gfx::Size present_size_;
 150
 151   // This is a shared texture that is being presented from.
 152   base::win::ScopedComPtr<IDirect3DTexture9> source_texture_;
 153
 154   // The swap chain is presented to the child window. Copy semantics
 155   // are used so it is possible to represent it to quickly validate the window.
 156   base::win::ScopedComPtr<IDirect3DSwapChain9> swap_chain_;
 157
 158   // Whether the window is hidden or has not been presented to since it was
 159   // last hidden.
 160   bool hidden_;
 161
 162   // Set to true if the first present after the tab is unhidden needs to be done
 163   // with GDI.
 164   bool do_present_with_GDI_;
 165
 166   // Set to true when the Windows session is locked.
 167   bool is_session_locked_;
 168
 169   // These are used to detect when the window is resizing. For some reason,
 170   // presenting with D3D while the window resizes causes those parts not
 171   // drawn with D3D (e.g. with GDI) to flicker visible / invisible.
 172   // http://crbug.com/120904
 173   gfx::Size last_window_size_;
 174   base::Time last_window_resize_time_;
 175
 176   ui::LatencyInfo latency_info_;
 177
 178   DISALLOW_COPY_AND_ASSIGN(AcceleratedPresenter);
 179 };
 180
 181 class SURFACE_EXPORT AcceleratedSurface {
 182  public:
 183   AcceleratedSurface(gfx::PluginWindowHandle window);
 184   ~AcceleratedSurface();
 185
 186   // Synchronously present a frame with no acknowledgement.
 187   void Present(HDC dc);
 188
 189   // Returns true if the surface is fully initialized and has been presented to
 190   // at least once.
 191   bool IsReadyForCopy() const;
 192
 193   // Transfer the contents of the surface to an SkBitmap, and invoke a callback
 194   // with the result.
 195   void AsyncCopyTo(const gfx::Rect& src_subrect,
 196                    const gfx::Size& dst_size,
 197                    const base::Callback<void(bool, const SkBitmap&)>& callback);
 198
 199   // Transfer the contents of the surface to an already-allocated YV12
 200   // VideoFrame, and invoke a callback to indicate success or failure.
 201   void AsyncCopyToVideoFrame(
 202       const gfx::Rect& src_subrect,
 203       const scoped_refptr<media::VideoFrame>& target,
 204       const base::Callback<void(bool)>& callback);
 205
 206   // Temporarily release resources until a new surface is asynchronously
 207   // presented. Present will not be able to represent the last surface after
 208   // calling this and will return false.
 209   void Suspend();
 210
 211   // Indicates that the surface has become invisible.
 212   void WasHidden();
 213
 214   // Called when the Windows session in locked or unlocked.
 215   void SetIsSessionLocked(bool locked);
 216
 217  private:
 218   const scoped_refptr<AcceleratedPresenter> presenter_;
 219   DISALLOW_COPY_AND_ASSIGN(AcceleratedSurface);
 220 };
 221
 222 #endif  // UI_SURFACE_ACCELERATED_SURFACE_WIN_H_