widget/windows/InProcessWinCompositorWidget.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "InProcessWinCompositorWidget.h"
   7
   8 #include "mozilla/StaticPrefs_layers.h"
   9 #include "mozilla/gfx/DeviceManagerDx.h"
  10 #include "mozilla/gfx/Point.h"
  11 #include "mozilla/layers/Compositor.h"
  12 #include "mozilla/layers/CompositorThread.h"
  13 #include "mozilla/webrender/RenderThread.h"
  14 #include "mozilla/widget/PlatformWidgetTypes.h"
  15 #include "gfxPlatform.h"
  16 #include "HeadlessCompositorWidget.h"
  17 #include "HeadlessWidget.h"
  18 #include "nsIWidget.h"
  19 #include "nsWindow.h"
  20 #include "VsyncDispatcher.h"
  21 #include "WinCompositorWindowThread.h"
  22 #include "VRShMem.h"
  23
  24 #include <ddraw.h>
  25
  26 namespace mozilla::widget {
  27
  28 using namespace mozilla::gfx;
  29 using namespace mozilla;
  30
  31 /* static */
  32 RefPtr<CompositorWidget> CompositorWidget::CreateLocal(
  33     const CompositorWidgetInitData& aInitData,
  34     const layers::CompositorOptions& aOptions, nsIWidget* aWidget) {
  35   if (aInitData.type() ==
  36       CompositorWidgetInitData::THeadlessCompositorWidgetInitData) {
  37     return new HeadlessCompositorWidget(
  38         aInitData.get_HeadlessCompositorWidgetInitData(), aOptions,
  39         static_cast<HeadlessWidget*>(aWidget));
  40   } else {
  41     return new InProcessWinCompositorWidget(
  42         aInitData.get_WinCompositorWidgetInitData(), aOptions,
  43         static_cast<nsWindow*>(aWidget));
  44   }
  45 }
  46
  47 InProcessWinCompositorWidget::InProcessWinCompositorWidget(
  48     const WinCompositorWidgetInitData& aInitData,
  49     const layers::CompositorOptions& aOptions, nsWindow* aWindow)
  50     : WinCompositorWidget(aInitData, aOptions),
  51       mWindow(aWindow),
  52       mWnd(reinterpret_cast<HWND>(aInitData.hWnd())),
  53       mTransparentSurfaceLock("mTransparentSurfaceLock"),
  54       mTransparencyMode(uint32_t(aInitData.transparencyMode())),
  55       mMemoryDC(nullptr),
  56       mCompositeDC(nullptr),
  57       mLockedBackBufferData(nullptr) {
  58   MOZ_ASSERT(mWindow);
  59   MOZ_ASSERT(mWnd && ::IsWindow(mWnd));
  60
  61   // mNotDeferEndRemoteDrawing is set on the main thread during init,
  62   // but is only accessed after on the compositor thread.
  63   mNotDeferEndRemoteDrawing =
  64       StaticPrefs::layers_offmainthreadcomposition_frame_rate() == 0 ||
  65       gfxPlatform::IsInLayoutAsapMode() || gfxPlatform::ForceSoftwareVsync();
  66 }
  67
  68 void InProcessWinCompositorWidget::OnDestroyWindow() {
  69   gfx::CriticalSectionAutoEnter presentLock(&mPresentLock);
  70   MutexAutoLock lock(mTransparentSurfaceLock);
  71   mTransparentSurface = nullptr;
  72   mMemoryDC = nullptr;
  73 }
  74
  75 bool InProcessWinCompositorWidget::OnWindowResize(
  76     const LayoutDeviceIntSize& aSize) {
  77   return true;
  78 }
  79
  80 void InProcessWinCompositorWidget::OnWindowModeChange(nsSizeMode aSizeMode) {}
  81
  82 bool InProcessWinCompositorWidget::PreRender(WidgetRenderingContext* aContext) {
  83   // This can block waiting for WM_SETTEXT to finish
  84   // Using PreRender is unnecessarily pessimistic because
  85   // we technically only need to block during the present call
  86   // not all of compositor rendering
  87   mPresentLock.Enter();
  88   return true;
  89 }
  90
  91 void InProcessWinCompositorWidget::PostRender(
  92     WidgetRenderingContext* aContext) {
  93   mPresentLock.Leave();
  94 }
  95
  96 LayoutDeviceIntSize InProcessWinCompositorWidget::GetClientSize() {
  97   RECT r;
  98   if (!::GetClientRect(mWnd, &r)) {
  99     return LayoutDeviceIntSize();
 100   }
 101   return LayoutDeviceIntSize(r.right - r.left, r.bottom - r.top);
 102 }
 103
 104 already_AddRefed<gfx::DrawTarget>
 105 InProcessWinCompositorWidget::StartRemoteDrawing() {
 106   MutexAutoLock lock(mTransparentSurfaceLock);
 107
 108   MOZ_ASSERT(!mCompositeDC);
 109
 110   RefPtr<gfxASurface> surf;
 111   if (TransparencyModeIs(TransparencyMode::Transparent)) {
 112     surf = EnsureTransparentSurface();
 113   }
 114
 115   // Must call this after EnsureTransparentSurface(), since it could update
 116   // the DC.
 117   HDC dc = GetWindowSurface();
 118   if (!surf) {
 119     if (!dc) {
 120       return nullptr;
 121     }
 122     uint32_t flags = TransparencyModeIs(TransparencyMode::Opaque)
 123                          ? 0
 124                          : gfxWindowsSurface::FLAG_IS_TRANSPARENT;
 125     surf = new gfxWindowsSurface(dc, flags);
 126   }
 127
 128   IntSize size = surf->GetSize();
 129   if (size.width <= 0 || size.height <= 0) {
 130     if (dc) {
 131       FreeWindowSurface(dc);
 132     }
 133     return nullptr;
 134   }
 135
 136   RefPtr<DrawTarget> dt =
 137       mozilla::gfx::Factory::CreateDrawTargetForCairoSurface(
 138           surf->CairoSurface(), size);
 139   if (dt) {
 140     mCompositeDC = dc;
 141   } else {
 142     FreeWindowSurface(dc);
 143   }
 144
 145   return dt.forget();
 146 }
 147
 148 void InProcessWinCompositorWidget::EndRemoteDrawing() {
 149   MOZ_ASSERT(!mLockedBackBufferData);
 150
 151   if (TransparencyModeIs(TransparencyMode::Transparent)) {
 152     MOZ_ASSERT(mTransparentSurface);
 153     RedrawTransparentWindow();
 154   }
 155   if (mCompositeDC) {
 156     FreeWindowSurface(mCompositeDC);
 157   }
 158   mCompositeDC = nullptr;
 159 }
 160
 161 bool InProcessWinCompositorWidget::NeedsToDeferEndRemoteDrawing() {
 162   if (mNotDeferEndRemoteDrawing) {
 163     return false;
 164   }
 165
 166   IDirectDraw7* ddraw = DeviceManagerDx::Get()->GetDirectDraw();
 167   if (!ddraw) {
 168     return false;
 169   }
 170
 171   DWORD scanLine = 0;
 172   int height = ::GetSystemMetrics(SM_CYSCREEN);
 173   HRESULT ret = ddraw->GetScanLine(&scanLine);
 174   if (ret == DDERR_VERTICALBLANKINPROGRESS) {
 175     scanLine = 0;
 176   } else if (ret != DD_OK) {
 177     return false;
 178   }
 179
 180   // Check if there is a risk of tearing with GDI.
 181   if (static_cast<int>(scanLine) > height / 2) {
 182     // No need to defer.
 183     return false;
 184   }
 185
 186   return true;
 187 }
 188
 189 already_AddRefed<gfx::DrawTarget>
 190 InProcessWinCompositorWidget::GetBackBufferDrawTarget(
 191     gfx::DrawTarget* aScreenTarget, const gfx::IntRect& aRect,
 192     bool* aOutIsCleared) {
 193   MOZ_ASSERT(!mLockedBackBufferData);
 194
 195   RefPtr<gfx::DrawTarget> target = CompositorWidget::GetBackBufferDrawTarget(
 196       aScreenTarget, aRect, aOutIsCleared);
 197   if (!target) {
 198     return nullptr;
 199   }
 200
 201   MOZ_ASSERT(target->GetBackendType() == BackendType::CAIRO);
 202
 203   uint8_t* destData;
 204   IntSize destSize;
 205   int32_t destStride;
 206   SurfaceFormat destFormat;
 207   if (!target->LockBits(&destData, &destSize, &destStride, &destFormat)) {
 208     // LockBits is not supported. Use original DrawTarget.
 209     return target.forget();
 210   }
 211
 212   RefPtr<gfx::DrawTarget> dataTarget = Factory::CreateDrawTargetForData(
 213       BackendType::CAIRO, destData, destSize, destStride, destFormat);
 214   mLockedBackBufferData = destData;
 215
 216   return dataTarget.forget();
 217 }
 218
 219 already_AddRefed<gfx::SourceSurface>
 220 InProcessWinCompositorWidget::EndBackBufferDrawing() {
 221   if (mLockedBackBufferData) {
 222     MOZ_ASSERT(mLastBackBuffer);
 223     mLastBackBuffer->ReleaseBits(mLockedBackBufferData);
 224     mLockedBackBufferData = nullptr;
 225   }
 226   return CompositorWidget::EndBackBufferDrawing();
 227 }
 228
 229 bool InProcessWinCompositorWidget::InitCompositor(
 230     layers::Compositor* aCompositor) {
 231   return true;
 232 }
 233
 234 void InProcessWinCompositorWidget::EnterPresentLock() { mPresentLock.Enter(); }
 235
 236 void InProcessWinCompositorWidget::LeavePresentLock() { mPresentLock.Leave(); }
 237
 238 RefPtr<gfxASurface> InProcessWinCompositorWidget::EnsureTransparentSurface() {
 239   mTransparentSurfaceLock.AssertCurrentThreadOwns();
 240   MOZ_ASSERT(TransparencyModeIs(TransparencyMode::Transparent));
 241
 242   IntSize size = GetClientSize().ToUnknownSize();
 243   if (!mTransparentSurface || mTransparentSurface->GetSize() != size) {
 244     mTransparentSurface = nullptr;
 245     mMemoryDC = nullptr;
 246     CreateTransparentSurface(size);
 247   }
 248
 249   RefPtr<gfxASurface> surface = mTransparentSurface;
 250   return surface.forget();
 251 }
 252
 253 void InProcessWinCompositorWidget::CreateTransparentSurface(
 254     const gfx::IntSize& aSize) {
 255   mTransparentSurfaceLock.AssertCurrentThreadOwns();
 256   MOZ_ASSERT(!mTransparentSurface && !mMemoryDC);
 257   RefPtr<gfxWindowsSurface> surface =
 258       new gfxWindowsSurface(aSize, SurfaceFormat::A8R8G8B8_UINT32);
 259   mTransparentSurface = surface;
 260   mMemoryDC = surface->GetDC();
 261 }
 262
 263 void InProcessWinCompositorWidget::UpdateTransparency(TransparencyMode aMode) {
 264   gfx::CriticalSectionAutoEnter presentLock(&mPresentLock);
 265   MutexAutoLock lock(mTransparentSurfaceLock);
 266   if (TransparencyModeIs(aMode)) {
 267     return;
 268   }
 269
 270   mTransparencyMode = uint32_t(aMode);
 271   mTransparentSurface = nullptr;
 272   mMemoryDC = nullptr;
 273
 274   if (aMode == TransparencyMode::Transparent) {
 275     EnsureTransparentSurface();
 276   }
 277 }
 278
 279 void InProcessWinCompositorWidget::NotifyVisibilityUpdated(
 280     nsSizeMode aSizeMode, bool aIsFullyOccluded) {
 281   mSizeMode = aSizeMode;
 282   mIsFullyOccluded = aIsFullyOccluded;
 283 }
 284
 285 nsSizeMode InProcessWinCompositorWidget::GetWindowSizeMode() const {
 286   nsSizeMode sizeMode = mSizeMode;
 287   return sizeMode;
 288 }
 289
 290 bool InProcessWinCompositorWidget::GetWindowIsFullyOccluded() const {
 291   bool isFullyOccluded = mIsFullyOccluded;
 292   return isFullyOccluded;
 293 }
 294
 295 void InProcessWinCompositorWidget::ClearTransparentWindow() {
 296   gfx::CriticalSectionAutoEnter presentLock(&mPresentLock);
 297   MutexAutoLock lock(mTransparentSurfaceLock);
 298   if (!mTransparentSurface) {
 299     return;
 300   }
 301
 302   EnsureTransparentSurface();
 303
 304   IntSize size = mTransparentSurface->GetSize();
 305   if (!size.IsEmpty()) {
 306     RefPtr<DrawTarget> drawTarget =
 307         gfxPlatform::CreateDrawTargetForSurface(mTransparentSurface, size);
 308     if (!drawTarget) {
 309       return;
 310     }
 311     drawTarget->ClearRect(Rect(0, 0, size.width, size.height));
 312     RedrawTransparentWindow();
 313   }
 314 }
 315
 316 bool InProcessWinCompositorWidget::RedrawTransparentWindow() {
 317   MOZ_ASSERT(TransparencyModeIs(TransparencyMode::Transparent));
 318
 319   LayoutDeviceIntSize size = GetClientSize();
 320
 321   ::GdiFlush();
 322
 323   BLENDFUNCTION bf = {AC_SRC_OVER, 0, 255, AC_SRC_ALPHA};
 324   SIZE winSize = {size.width, size.height};
 325   POINT srcPos = {0, 0};
 326   HWND hWnd = WinUtils::GetTopLevelHWND(mWnd, true);
 327   RECT winRect;
 328   ::GetWindowRect(hWnd, &winRect);
 329
 330   // perform the alpha blend
 331   return !!::UpdateLayeredWindow(hWnd, nullptr, (POINT*)&winRect, &winSize,
 332                                  mMemoryDC, &srcPos, 0, &bf, ULW_ALPHA);
 333 }
 334
 335 HDC InProcessWinCompositorWidget::GetWindowSurface() {
 336   return TransparencyModeIs(TransparencyMode::Transparent) ? mMemoryDC
 337                                                            : ::GetDC(mWnd);
 338 }
 339
 340 void InProcessWinCompositorWidget::FreeWindowSurface(HDC dc) {
 341   if (!TransparencyModeIs(TransparencyMode::Transparent)) {
 342     ::ReleaseDC(mWnd, dc);
 343   }
 344 }
 345
 346 bool InProcessWinCompositorWidget::IsHidden() const { return ::IsIconic(mWnd); }
 347
 348 nsIWidget* InProcessWinCompositorWidget::RealWidget() { return mWindow; }
 349
 350 void InProcessWinCompositorWidget::ObserveVsync(VsyncObserver* aObserver) {
 351   if (RefPtr<CompositorVsyncDispatcher> cvd =
 352           mWindow->GetCompositorVsyncDispatcher()) {
 353     cvd->SetCompositorVsyncObserver(aObserver);
 354   }
 355 }
 356
 357 void InProcessWinCompositorWidget::UpdateCompositorWnd(
 358     const HWND aCompositorWnd, const HWND aParentWnd) {
 359   MOZ_ASSERT(layers::CompositorThreadHolder::IsInCompositorThread());
 360   MOZ_ASSERT(aCompositorWnd && aParentWnd);
 361   MOZ_ASSERT(aParentWnd == mWnd);
 362
 363   // Since we're in the parent process anyway, we can just call SetParent
 364   // directly.
 365   ::SetParent(aCompositorWnd, aParentWnd);
 366   mSetParentCompleted = true;
 367 }
 368 }  // namespace mozilla::widget