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 #include "mozilla/StaticPrefs_gfx.h"
  14
  15 using namespace mozilla::layers;
  16
  17 namespace mozilla {
  18
  19 CompositorVsyncDispatcher::CompositorVsyncDispatcher(
  20     RefPtr<VsyncDispatcher> aVsyncDispatcher)
  21     : mVsyncDispatcher(std::move(aVsyncDispatcher)),
  22       mCompositorObserverLock("CompositorObserverLock"),
  23       mDidShutdown(false) {
  24   MOZ_ASSERT(XRE_IsParentProcess());
  25   MOZ_ASSERT(NS_IsMainThread());
  26 }
  27
  28 CompositorVsyncDispatcher::~CompositorVsyncDispatcher() {
  29   MOZ_ASSERT(XRE_IsParentProcess());
  30 }
  31
  32 void CompositorVsyncDispatcher::NotifyVsync(const VsyncEvent& aVsync) {
  33   // In vsync thread
  34   layers::CompositorBridgeParent::PostInsertVsyncProfilerMarker(aVsync.mTime);
  35
  36   MutexAutoLock lock(mCompositorObserverLock);
  37   if (mCompositorVsyncObserver) {
  38     mCompositorVsyncObserver->NotifyVsync(aVsync);
  39   }
  40 }
  41
  42 void CompositorVsyncDispatcher::ObserveVsync(bool aEnable) {
  43   MOZ_ASSERT(NS_IsMainThread());
  44   MOZ_ASSERT(XRE_IsParentProcess());
  45   if (mDidShutdown) {
  46     return;
  47   }
  48
  49   if (aEnable) {
  50     mVsyncDispatcher->AddVsyncObserver(this);
  51   } else {
  52     mVsyncDispatcher->RemoveVsyncObserver(this);
  53   }
  54 }
  55
  56 void CompositorVsyncDispatcher::SetCompositorVsyncObserver(
  57     VsyncObserver* aVsyncObserver) {
  58   // When remote compositing or running gtests, vsync observation is
  59   // initiated on the main thread. Otherwise, it is initiated from the
  60   // compositor thread.
  61   MOZ_ASSERT(NS_IsMainThread() ||
  62              CompositorThreadHolder::IsInCompositorThread());
  63
  64   {  // scope lock
  65     MutexAutoLock lock(mCompositorObserverLock);
  66     mCompositorVsyncObserver = aVsyncObserver;
  67   }
  68
  69   bool observeVsync = aVsyncObserver != nullptr;
  70   nsCOMPtr<nsIRunnable> vsyncControl = NewRunnableMethod<bool>(
  71       "CompositorVsyncDispatcher::ObserveVsync", this,
  72       &CompositorVsyncDispatcher::ObserveVsync, observeVsync);
  73   NS_DispatchToMainThread(vsyncControl);
  74 }
  75
  76 void CompositorVsyncDispatcher::Shutdown() {
  77   // Need to explicitly remove CompositorVsyncDispatcher when the nsBaseWidget
  78   // shuts down. Otherwise, we would get dead vsync notifications between when
  79   // the nsBaseWidget shuts down and the CompositorBridgeParent shuts down.
  80   MOZ_ASSERT(XRE_IsParentProcess());
  81   MOZ_ASSERT(NS_IsMainThread());
  82   MOZ_ASSERT(!mDidShutdown);
  83   ObserveVsync(false);
  84   mDidShutdown = true;
  85   {  // scope lock
  86     MutexAutoLock lock(mCompositorObserverLock);
  87     mCompositorVsyncObserver = nullptr;
  88   }
  89   mVsyncDispatcher = nullptr;
  90 }
  91
  92 VsyncDispatcher::VsyncDispatcher(gfx::VsyncSource* aVsyncSource)
  93     : mState(State(aVsyncSource), "VsyncDispatcher::mState") {
  94   MOZ_ASSERT(XRE_IsParentProcess());
  95   MOZ_ASSERT(NS_IsMainThread());
  96 }
  97
  98 VsyncDispatcher::~VsyncDispatcher() {
  99   MOZ_ASSERT(XRE_IsParentProcess());
 100   MOZ_ASSERT(NS_IsMainThread());
 101 }
 102
 103 void VsyncDispatcher::SetVsyncSource(gfx::VsyncSource* aVsyncSource) {
 104   MOZ_RELEASE_ASSERT(aVsyncSource);
 105
 106   auto state = mState.Lock();
 107   if (aVsyncSource == state->mCurrentVsyncSource) {
 108     return;
 109   }
 110
 111   if (state->mIsObservingVsync) {
 112     state->mCurrentVsyncSource->RemoveVsyncDispatcher(this);
 113     aVsyncSource->AddVsyncDispatcher(this);
 114   }
 115   state->mCurrentVsyncSource = aVsyncSource;
 116 }
 117
 118 RefPtr<gfx::VsyncSource> VsyncDispatcher::GetCurrentVsyncSource() {
 119   auto state = mState.Lock();
 120   return state->mCurrentVsyncSource;
 121 }
 122
 123 TimeDuration VsyncDispatcher::GetVsyncRate() {
 124   auto state = mState.Lock();
 125   return state->mCurrentVsyncSource->GetVsyncRate();
 126 }
 127
 128 void VsyncDispatcher::NotifyVsync(const VsyncEvent& aVsync) {
 129   if (++mVsyncSkipCounter < StaticPrefs::gfx_display_frame_rate_divisor()) {
 130     return;
 131   }
 132   mVsyncSkipCounter = 0;
 133
 134   nsTArray<RefPtr<VsyncObserver>> observers;
 135   bool shouldDispatchToMainThread = false;
 136   {
 137     // Copy out the observers so that we don't keep the mutex
 138     // locked while notifying vsync.
 139     auto state = mState.Lock();
 140     observers = state->mObservers.Clone();
 141     shouldDispatchToMainThread = !state->mMainThreadObservers.IsEmpty() &&
 142                                  (state->mLastVsyncIdSentToMainThread ==
 143                                   state->mLastMainThreadProcessedVsyncId);
 144   }
 145
 146   for (const auto& observer : observers) {
 147     observer->NotifyVsync(aVsync);
 148   }
 149
 150   if (shouldDispatchToMainThread) {
 151     auto state = mState.Lock();
 152     state->mLastVsyncIdSentToMainThread = aVsync.mId;
 153     NS_DispatchToMainThread(NewRunnableMethod<VsyncEvent>(
 154         "VsyncDispatcher::NotifyMainThreadObservers", this,
 155         &VsyncDispatcher::NotifyMainThreadObservers, aVsync));
 156   }
 157 }
 158
 159 void VsyncDispatcher::NotifyMainThreadObservers(VsyncEvent aEvent) {
 160   MOZ_ASSERT(NS_IsMainThread());
 161   nsTArray<RefPtr<VsyncObserver>> observers;
 162   {
 163     // Copy out the main thread observers so that we don't keep the mutex
 164     // locked while notifying vsync.
 165     auto state = mState.Lock();
 166     observers.AppendElements(state->mMainThreadObservers);
 167   }
 168
 169   for (const auto& observer : observers) {
 170     observer->NotifyVsync(aEvent);
 171   }
 172
 173   {  // Scope lock
 174     auto state = mState.Lock();
 175     state->mLastMainThreadProcessedVsyncId = aEvent.mId;
 176   }
 177 }
 178
 179 void VsyncDispatcher::AddVsyncObserver(VsyncObserver* aVsyncObserver) {
 180   MOZ_ASSERT(aVsyncObserver);
 181   {  // scope lock - called on PBackground thread or main thread
 182     auto state = mState.Lock();
 183     if (!state->mObservers.Contains(aVsyncObserver)) {
 184       state->mObservers.AppendElement(aVsyncObserver);
 185     }
 186   }
 187
 188   UpdateVsyncStatus();
 189 }
 190
 191 void VsyncDispatcher::RemoveVsyncObserver(VsyncObserver* aVsyncObserver) {
 192   MOZ_ASSERT(aVsyncObserver);
 193   {  // scope lock - called on PBackground thread or main thread
 194     auto state = mState.Lock();
 195     state->mObservers.RemoveElement(aVsyncObserver);
 196   }
 197
 198   UpdateVsyncStatus();
 199 }
 200
 201 void VsyncDispatcher::AddMainThreadObserver(VsyncObserver* aObserver) {
 202   MOZ_ASSERT(NS_IsMainThread());
 203   MOZ_ASSERT(aObserver);
 204   {
 205     auto state = mState.Lock();
 206     state->mMainThreadObservers.AppendElement(aObserver);
 207   }
 208
 209   UpdateVsyncStatus();
 210 }
 211
 212 void VsyncDispatcher::RemoveMainThreadObserver(VsyncObserver* aObserver) {
 213   MOZ_ASSERT(NS_IsMainThread());
 214   MOZ_ASSERT(aObserver);
 215   {
 216     auto state = mState.Lock();
 217     state->mMainThreadObservers.RemoveElement(aObserver);
 218   }
 219
 220   UpdateVsyncStatus();
 221 }
 222
 223 void VsyncDispatcher::UpdateVsyncStatus() {
 224   bool wasObservingVsync = false;
 225   bool needVsync = false;
 226   RefPtr<VsyncSource> vsyncSource;
 227
 228   {
 229     auto state = mState.Lock();
 230     wasObservingVsync = state->mIsObservingVsync;
 231     needVsync =
 232         !state->mObservers.IsEmpty() || !state->mMainThreadObservers.IsEmpty();
 233     state->mIsObservingVsync = needVsync;
 234     vsyncSource = state->mCurrentVsyncSource;
 235   }
 236
 237   // Call Add/RemoveVsyncDispatcher outside the lock, because it can re-enter
 238   // into VsyncDispatcher::NotifyVsync.
 239   if (needVsync && !wasObservingVsync) {
 240     vsyncSource->AddVsyncDispatcher(this);
 241   } else if (!needVsync && wasObservingVsync) {
 242     vsyncSource->RemoveVsyncDispatcher(this);
 243   }
 244 }
 245
 246 }  // namespace mozilla