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