gfx/thebes/VsyncSource.cpp

   1 /* -*- Mode: C++; tab-width: 20; 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 "VsyncSource.h"
   7 #include "nsThreadUtils.h"
   8 #include "nsXULAppAPI.h"
   9 #include "mozilla/VsyncDispatcher.h"
  10 #include "MainThreadUtils.h"
  11
  12 namespace mozilla {
  13 namespace gfx {
  14
  15 void VsyncSource::EnableCompositorVsyncDispatcher(
  16     CompositorVsyncDispatcher* aCompositorVsyncDispatcher) {
  17   MOZ_ASSERT(XRE_IsParentProcess());
  18   MOZ_ASSERT(NS_IsMainThread());
  19   // Just use the global display until we have enough information to get the
  20   // corresponding display for compositor.
  21   GetGlobalDisplay().EnableCompositorVsyncDispatcher(
  22       aCompositorVsyncDispatcher);
  23 }
  24
  25 void VsyncSource::DisableCompositorVsyncDispatcher(
  26     CompositorVsyncDispatcher* aCompositorVsyncDispatcher) {
  27   MOZ_ASSERT(XRE_IsParentProcess());
  28   MOZ_ASSERT(NS_IsMainThread());
  29   // See also EnableCompositorVsyncDispatcher().
  30   GetGlobalDisplay().DisableCompositorVsyncDispatcher(
  31       aCompositorVsyncDispatcher);
  32 }
  33
  34 void VsyncSource::RegisterCompositorVsyncDispatcher(
  35     CompositorVsyncDispatcher* aCompositorVsyncDispatcher) {
  36   MOZ_ASSERT(XRE_IsParentProcess());
  37   MOZ_ASSERT(NS_IsMainThread());
  38   GetGlobalDisplay().RegisterCompositorVsyncDispatcher(
  39       aCompositorVsyncDispatcher);
  40 }
  41
  42 void VsyncSource::DeregisterCompositorVsyncDispatcher(
  43     CompositorVsyncDispatcher* aCompositorVsyncDispatcher) {
  44   MOZ_ASSERT(XRE_IsParentProcess());
  45   MOZ_ASSERT(NS_IsMainThread());
  46   GetGlobalDisplay().DeregisterCompositorVsyncDispatcher(
  47       aCompositorVsyncDispatcher);
  48 }
  49
  50 void VsyncSource::AddGenericObserver(VsyncObserver* aObserver) {
  51   MOZ_ASSERT(XRE_IsParentProcess());
  52   MOZ_ASSERT(NS_IsMainThread());
  53
  54   GetGlobalDisplay().AddGenericObserver(aObserver);
  55 }
  56
  57 void VsyncSource::RemoveGenericObserver(VsyncObserver* aObserver) {
  58   MOZ_ASSERT(XRE_IsParentProcess());
  59   MOZ_ASSERT(NS_IsMainThread());
  60
  61   GetGlobalDisplay().RemoveGenericObserver(aObserver);
  62 }
  63
  64 void VsyncSource::MoveListenersToNewSource(
  65     const RefPtr<VsyncSource>& aNewSource) {
  66   GetGlobalDisplay().MoveListenersToNewSource(aNewSource);
  67 }
  68
  69 RefPtr<RefreshTimerVsyncDispatcher>
  70 VsyncSource::GetRefreshTimerVsyncDispatcher() {
  71   MOZ_ASSERT(XRE_IsParentProcess());
  72   // See also AddCompositorVsyncDispatcher().
  73   return GetGlobalDisplay().GetRefreshTimerVsyncDispatcher();
  74 }
  75
  76 VsyncSource::Display::Display()
  77     : mDispatcherLock("display dispatcher lock"),
  78       mRefreshTimerNeedsVsync(false),
  79       mHasGenericObservers(false) {
  80   MOZ_ASSERT(NS_IsMainThread());
  81   mRefreshTimerVsyncDispatcher = new RefreshTimerVsyncDispatcher(this);
  82 }
  83
  84 VsyncSource::Display::~Display() {
  85   MOZ_ASSERT(NS_IsMainThread());
  86   MutexAutoLock lock(mDispatcherLock);
  87   mRefreshTimerVsyncDispatcher = nullptr;
  88   MOZ_ASSERT(mRegisteredCompositorVsyncDispatchers.Length() == 0);
  89   MOZ_ASSERT(mEnabledCompositorVsyncDispatchers.Length() == 0);
  90 }
  91
  92 void VsyncSource::Display::NotifyVsync(const TimeStamp& aVsyncTimestamp,
  93                                        const TimeStamp& aOutputTimestamp) {
  94   // Called on the vsync thread
  95   MutexAutoLock lock(mDispatcherLock);
  96
  97   // mRefreshTimerVsyncDispatcher might be null here if MoveListenersToNewSource
  98   // was called concurrently with this function and won the race to acquire
  99   // mDispatcherLock. In this case the new VsyncSource that is replacing this
 100   // one will handle notifications from now on, so we can abort.
 101   if (!mRefreshTimerVsyncDispatcher) {
 102     return;
 103   }
 104
 105   // If the task posted to the main thread from the last NotifyVsync call
 106   // hasn't been processed yet, then don't send another one. Otherwise we might
 107   // end up flooding the main thread.
 108   bool dispatchToMainThread =
 109       mHasGenericObservers &&
 110       (mLastVsyncIdSentToMainThread == mLastMainThreadProcessedVsyncId);
 111
 112   mVsyncId = mVsyncId.Next();
 113   const VsyncEvent event(mVsyncId, aVsyncTimestamp, aOutputTimestamp);
 114
 115   for (size_t i = 0; i < mEnabledCompositorVsyncDispatchers.Length(); i++) {
 116     mEnabledCompositorVsyncDispatchers[i]->NotifyVsync(event);
 117   }
 118
 119   mRefreshTimerVsyncDispatcher->NotifyVsync(event);
 120
 121   if (dispatchToMainThread) {
 122     mLastVsyncIdSentToMainThread = mVsyncId;
 123     NS_DispatchToMainThread(NewRunnableMethod<VsyncEvent>(
 124         "VsyncSource::Display::NotifyGenericObservers", this,
 125         &VsyncSource::Display::NotifyGenericObservers, event));
 126   }
 127 }
 128
 129 void VsyncSource::Display::NotifyGenericObservers(VsyncEvent aEvent) {
 130   MOZ_ASSERT(NS_IsMainThread());
 131   for (size_t i = 0; i < mGenericObservers.Length(); i++) {
 132     mGenericObservers[i]->NotifyVsync(aEvent);
 133   }
 134
 135   {  // Scope lock
 136     MutexAutoLock lock(mDispatcherLock);
 137     mLastMainThreadProcessedVsyncId = aEvent.mId;
 138   }
 139 }
 140
 141 TimeDuration VsyncSource::Display::GetVsyncRate() {
 142   // If hardware queries fail / are unsupported, we have to just guess.
 143   return TimeDuration::FromMilliseconds(1000.0 / 60.0);
 144 }
 145
 146 void VsyncSource::Display::RegisterCompositorVsyncDispatcher(
 147     CompositorVsyncDispatcher* aCompositorVsyncDispatcher) {
 148   MOZ_ASSERT(NS_IsMainThread());
 149   MOZ_ASSERT(aCompositorVsyncDispatcher);
 150   {  // scope lock
 151     MutexAutoLock lock(mDispatcherLock);
 152     mRegisteredCompositorVsyncDispatchers.AppendElement(
 153         aCompositorVsyncDispatcher);
 154   }
 155 }
 156
 157 void VsyncSource::Display::DeregisterCompositorVsyncDispatcher(
 158     CompositorVsyncDispatcher* aCompositorVsyncDispatcher) {
 159   MOZ_ASSERT(NS_IsMainThread());
 160   MOZ_ASSERT(aCompositorVsyncDispatcher);
 161   {  // Scope lock
 162     MutexAutoLock lock(mDispatcherLock);
 163     mRegisteredCompositorVsyncDispatchers.RemoveElement(
 164         aCompositorVsyncDispatcher);
 165   }
 166 }
 167
 168 void VsyncSource::Display::EnableCompositorVsyncDispatcher(
 169     CompositorVsyncDispatcher* aCompositorVsyncDispatcher) {
 170   MOZ_ASSERT(NS_IsMainThread());
 171   MOZ_ASSERT(aCompositorVsyncDispatcher);
 172   {  // scope lock
 173     MutexAutoLock lock(mDispatcherLock);
 174     if (!mEnabledCompositorVsyncDispatchers.Contains(
 175             aCompositorVsyncDispatcher)) {
 176       mEnabledCompositorVsyncDispatchers.AppendElement(
 177           aCompositorVsyncDispatcher);
 178     }
 179   }
 180   UpdateVsyncStatus();
 181 }
 182
 183 void VsyncSource::Display::DisableCompositorVsyncDispatcher(
 184     CompositorVsyncDispatcher* aCompositorVsyncDispatcher) {
 185   MOZ_ASSERT(NS_IsMainThread());
 186   MOZ_ASSERT(aCompositorVsyncDispatcher);
 187   {  // Scope lock
 188     MutexAutoLock lock(mDispatcherLock);
 189     if (mEnabledCompositorVsyncDispatchers.Contains(
 190             aCompositorVsyncDispatcher)) {
 191       mEnabledCompositorVsyncDispatchers.RemoveElement(
 192           aCompositorVsyncDispatcher);
 193     }
 194   }
 195   UpdateVsyncStatus();
 196 }
 197
 198 void VsyncSource::Display::AddGenericObserver(VsyncObserver* aObserver) {
 199   MOZ_ASSERT(NS_IsMainThread());
 200   MOZ_ASSERT(aObserver);
 201   mGenericObservers.AppendElement(aObserver);
 202
 203   UpdateVsyncStatus();
 204 }
 205
 206 void VsyncSource::Display::RemoveGenericObserver(VsyncObserver* aObserver) {
 207   MOZ_ASSERT(NS_IsMainThread());
 208   MOZ_ASSERT(aObserver);
 209   mGenericObservers.RemoveElement(aObserver);
 210
 211   UpdateVsyncStatus();
 212 }
 213
 214 void VsyncSource::Display::MoveListenersToNewSource(
 215     const RefPtr<VsyncSource>& aNewSource) {
 216   MOZ_ASSERT(NS_IsMainThread());
 217   VsyncSource::Display& aNewDisplay = aNewSource->GetGlobalDisplay();
 218   MutexAutoLock lock(mDispatcherLock);
 219   MutexAutoLock newLock(aNewDisplay.mDispatcherLock);
 220   aNewDisplay.mRegisteredCompositorVsyncDispatchers.AppendElements(
 221       std::move(mRegisteredCompositorVsyncDispatchers));
 222   aNewDisplay.mEnabledCompositorVsyncDispatchers.AppendElements(
 223       std::move(mEnabledCompositorVsyncDispatchers));
 224   aNewDisplay.mGenericObservers.AppendElements(std::move(mGenericObservers));
 225
 226   for (size_t i = 0;
 227        i < aNewDisplay.mRegisteredCompositorVsyncDispatchers.Length(); i++) {
 228     aNewDisplay.mRegisteredCompositorVsyncDispatchers[i]->MoveToSource(
 229         aNewSource);
 230   }
 231
 232   aNewDisplay.mRefreshTimerVsyncDispatcher = mRefreshTimerVsyncDispatcher;
 233   mRefreshTimerVsyncDispatcher->MoveToDisplay(&aNewDisplay);
 234   mRefreshTimerVsyncDispatcher = nullptr;
 235 }
 236
 237 void VsyncSource::Display::NotifyRefreshTimerVsyncStatus(bool aEnable) {
 238   MOZ_ASSERT(NS_IsMainThread());
 239   mRefreshTimerNeedsVsync = aEnable;
 240   UpdateVsyncStatus();
 241 }
 242
 243 void VsyncSource::Display::UpdateVsyncStatus() {
 244   MOZ_ASSERT(NS_IsMainThread());
 245   // WARNING: This function SHOULD NOT BE CALLED WHILE HOLDING LOCKS
 246   // NotifyVsync grabs a lock to dispatch vsync events
 247   // When disabling vsync, we wait for the underlying thread to stop on some
 248   // platforms We can deadlock if we wait for the underlying vsync thread to
 249   // stop while the vsync thread is in NotifyVsync.
 250   bool enableVsync = false;
 251   {  // scope lock
 252     MutexAutoLock lock(mDispatcherLock);
 253     enableVsync = !mEnabledCompositorVsyncDispatchers.IsEmpty() ||
 254                   mRefreshTimerNeedsVsync || !mGenericObservers.IsEmpty();
 255     mHasGenericObservers = !mGenericObservers.IsEmpty();
 256   }
 257
 258   if (enableVsync) {
 259     EnableVsync();
 260   } else {
 261     DisableVsync();
 262   }
 263
 264   if (IsVsyncEnabled() != enableVsync) {
 265     NS_WARNING("Vsync status did not change.");
 266   }
 267 }
 268
 269 RefPtr<RefreshTimerVsyncDispatcher>
 270 VsyncSource::Display::GetRefreshTimerVsyncDispatcher() {
 271   return mRefreshTimerVsyncDispatcher;
 272 }
 273
 274 void VsyncSource::Shutdown() { GetGlobalDisplay().Shutdown(); }
 275
 276 }  // namespace gfx
 277 }  // namespace mozilla