widget/VsyncDispatcher.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 "MainThreadUtils.h"
   7 #include "VsyncDispatcher.h"
   8 #include "VsyncSource.h"
   9 #include "gfxPlatform.h"
  10 #include "mozilla/layers/Compositor.h"
  11 #include "mozilla/layers/CompositorBridgeParent.h"
  12 #include "mozilla/layers/CompositorThread.h"
  13
  14 using namespace mozilla::layers;
  15
  16 namespace mozilla {
  17
  18 CompositorVsyncDispatcher::CompositorVsyncDispatcher()
  19     : mCompositorObserverLock("CompositorObserverLock"), mDidShutdown(false) {
  20   MOZ_ASSERT(XRE_IsParentProcess());
  21   MOZ_ASSERT(NS_IsMainThread());
  22 }
  23
  24 CompositorVsyncDispatcher::~CompositorVsyncDispatcher() {
  25   MOZ_ASSERT(XRE_IsParentProcess());
  26   // We auto remove this vsync dispatcher from the vsync source in the
  27   // nsBaseWidget
  28 }
  29
  30 void CompositorVsyncDispatcher::NotifyVsync(const VsyncEvent& aVsync) {
  31   // In vsync thread
  32   layers::CompositorBridgeParent::PostInsertVsyncProfilerMarker(aVsync.mTime);
  33
  34   MutexAutoLock lock(mCompositorObserverLock);
  35   if (mCompositorVsyncObserver) {
  36     mCompositorVsyncObserver->NotifyVsync(aVsync);
  37   }
  38 }
  39
  40 void CompositorVsyncDispatcher::ObserveVsync(bool aEnable) {
  41   MOZ_ASSERT(NS_IsMainThread());
  42   MOZ_ASSERT(XRE_IsParentProcess());
  43   if (mDidShutdown) {
  44     return;
  45   }
  46
  47   if (aEnable) {
  48     gfxPlatform::GetPlatform()
  49         ->GetHardwareVsync()
  50         ->AddCompositorVsyncDispatcher(this);
  51   } else {
  52     gfxPlatform::GetPlatform()
  53         ->GetHardwareVsync()
  54         ->RemoveCompositorVsyncDispatcher(this);
  55   }
  56 }
  57
  58 void CompositorVsyncDispatcher::SetCompositorVsyncObserver(
  59     VsyncObserver* aVsyncObserver) {
  60   // When remote compositing or running gtests, vsync observation is
  61   // initiated on the main thread. Otherwise, it is initiated from the
  62   // compositor thread.
  63   MOZ_ASSERT(NS_IsMainThread() ||
  64              CompositorThreadHolder::IsInCompositorThread());
  65
  66   {  // scope lock
  67     MutexAutoLock lock(mCompositorObserverLock);
  68     mCompositorVsyncObserver = aVsyncObserver;
  69   }
  70
  71   bool observeVsync = aVsyncObserver != nullptr;
  72   nsCOMPtr<nsIRunnable> vsyncControl = NewRunnableMethod<bool>(
  73       "CompositorVsyncDispatcher::ObserveVsync", this,
  74       &CompositorVsyncDispatcher::ObserveVsync, observeVsync);
  75   NS_DispatchToMainThread(vsyncControl);
  76 }
  77
  78 void CompositorVsyncDispatcher::Shutdown() {
  79   // Need to explicitly remove CompositorVsyncDispatcher when the nsBaseWidget
  80   // shuts down. Otherwise, we would get dead vsync notifications between when
  81   // the nsBaseWidget shuts down and the CompositorBridgeParent shuts down.
  82   MOZ_ASSERT(XRE_IsParentProcess());
  83   MOZ_ASSERT(NS_IsMainThread());
  84   ObserveVsync(false);
  85   mDidShutdown = true;
  86   {  // scope lock
  87     MutexAutoLock lock(mCompositorObserverLock);
  88     mCompositorVsyncObserver = nullptr;
  89   }
  90 }
  91
  92 RefreshTimerVsyncDispatcher::RefreshTimerVsyncDispatcher()
  93     : mRefreshTimersLock("RefreshTimers lock") {
  94   MOZ_ASSERT(XRE_IsParentProcess() || recordreplay::IsRecordingOrReplaying());
  95   MOZ_ASSERT(NS_IsMainThread());
  96 }
  97
  98 RefreshTimerVsyncDispatcher::~RefreshTimerVsyncDispatcher() {
  99   MOZ_ASSERT(XRE_IsParentProcess() || recordreplay::IsRecordingOrReplaying());
 100   MOZ_ASSERT(NS_IsMainThread());
 101 }
 102
 103 void RefreshTimerVsyncDispatcher::NotifyVsync(const VsyncEvent& aVsync) {
 104   MutexAutoLock lock(mRefreshTimersLock);
 105
 106   for (size_t i = 0; i < mChildRefreshTimers.Length(); i++) {
 107     mChildRefreshTimers[i]->NotifyVsync(aVsync);
 108   }
 109
 110   if (mParentRefreshTimer) {
 111     mParentRefreshTimer->NotifyVsync(aVsync);
 112   }
 113 }
 114
 115 void RefreshTimerVsyncDispatcher::SetParentRefreshTimer(
 116     VsyncObserver* aVsyncObserver) {
 117   MOZ_ASSERT(NS_IsMainThread());
 118   {  // lock scope because UpdateVsyncStatus runs on main thread and will
 119      // deadlock
 120     MutexAutoLock lock(mRefreshTimersLock);
 121     mParentRefreshTimer = aVsyncObserver;
 122   }
 123
 124   UpdateVsyncStatus();
 125 }
 126
 127 void RefreshTimerVsyncDispatcher::AddChildRefreshTimer(
 128     VsyncObserver* aVsyncObserver) {
 129   {  // scope lock - called on pbackground thread
 130     MutexAutoLock lock(mRefreshTimersLock);
 131     MOZ_ASSERT(aVsyncObserver);
 132     if (!mChildRefreshTimers.Contains(aVsyncObserver)) {
 133       mChildRefreshTimers.AppendElement(aVsyncObserver);
 134     }
 135   }
 136
 137   UpdateVsyncStatus();
 138 }
 139
 140 void RefreshTimerVsyncDispatcher::RemoveChildRefreshTimer(
 141     VsyncObserver* aVsyncObserver) {
 142   {  // scope lock - called on pbackground thread
 143     MutexAutoLock lock(mRefreshTimersLock);
 144     MOZ_ASSERT(aVsyncObserver);
 145     mChildRefreshTimers.RemoveElement(aVsyncObserver);
 146   }
 147
 148   UpdateVsyncStatus();
 149 }
 150
 151 void RefreshTimerVsyncDispatcher::UpdateVsyncStatus() {
 152   if (!NS_IsMainThread()) {
 153     NS_DispatchToMainThread(NewRunnableMethod(
 154         "RefreshTimerVsyncDispatcher::UpdateVsyncStatus", this,
 155         &RefreshTimerVsyncDispatcher::UpdateVsyncStatus));
 156     return;
 157   }
 158
 159   gfx::VsyncSource::Display& display =
 160       gfxPlatform::GetPlatform()->GetHardwareVsync()->GetGlobalDisplay();
 161   display.NotifyRefreshTimerVsyncStatus(NeedsVsync());
 162 }
 163
 164 bool RefreshTimerVsyncDispatcher::NeedsVsync() {
 165   MOZ_ASSERT(NS_IsMainThread());
 166   MutexAutoLock lock(mRefreshTimersLock);
 167   return (mParentRefreshTimer != nullptr) || !mChildRefreshTimers.IsEmpty();
 168 }
 169
 170 }  // namespace mozilla