gfx/layers/ipc/AsyncTransactionTracker.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * vim: sw=2 ts=8 et :
   3  */
   4 /* This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   7
   8 #include "AsyncTransactionTracker.h"
   9
  10 #include "mozilla/layers/ImageBridgeChild.h"  // for ImageBridgeChild
  11
  12 namespace mozilla {
  13 namespace layers {
  14
  15 uint64_t AsyncTransactionTracker::sSerialCounter(0);
  16 Mutex* AsyncTransactionTracker::sLock = nullptr;
  17
  18 AsyncTransactionTracker::AsyncTransactionTracker()
  19     : mSerial(GetNextSerial())
  20     , mCompletedMonitor("AsyncTransactionTracker.mCompleted")
  21     , mCompleted(false)
  22 {
  23 }
  24
  25 AsyncTransactionTracker::~AsyncTransactionTracker()
  26 {
  27 }
  28
  29 void
  30 AsyncTransactionTracker::WaitComplete()
  31 {
  32   MOZ_ASSERT(!InImageBridgeChildThread());
  33
  34   MonitorAutoLock mon(mCompletedMonitor);
  35   int count = 0;
  36   const int maxCount = 5;
  37   while (!mCompleted && (count < maxCount)) {
  38     if (!NS_SUCCEEDED(mCompletedMonitor.Wait(PR_MillisecondsToInterval(10000)))) {
  39       NS_WARNING("Failed to wait Monitor");
  40       return;
  41     }
  42     if (count > 1) {
  43       printf_stderr("Waiting async transaction complete.\n");
  44     }
  45     count++;
  46   }
  47
  48   if (!mCompleted) {
  49     printf_stderr("Timeout of waiting transaction complete.");
  50   }
  51 }
  52
  53 void
  54 AsyncTransactionTracker::NotifyComplete()
  55 {
  56   MonitorAutoLock mon(mCompletedMonitor);
  57   MOZ_ASSERT(!mCompleted);
  58   mCompleted = true;
  59   Complete();
  60   mCompletedMonitor.Notify();
  61 }
  62
  63 void
  64 AsyncTransactionTracker::NotifyCancel()
  65 {
  66   MonitorAutoLock mon(mCompletedMonitor);
  67   MOZ_ASSERT(!mCompleted);
  68   mCompleted = true;
  69   Cancel();
  70   mCompletedMonitor.Notify();
  71 }
  72
  73 uint64_t AsyncTransactionTrackersHolder::sSerialCounter(0);
  74 Mutex* AsyncTransactionTrackersHolder::sHolderLock = nullptr;
  75
  76 std::map<uint64_t, AsyncTransactionTrackersHolder*> AsyncTransactionTrackersHolder::sTrackersHolders;
  77
  78 AsyncTransactionTrackersHolder::AsyncTransactionTrackersHolder()
  79   : mSerial(GetNextSerial())
  80   , mIsTrackersHolderDestroyed(false)
  81 {
  82   MOZ_COUNT_CTOR(AsyncTransactionTrackersHolder);
  83   {
  84     MOZ_ASSERT(sHolderLock);
  85     MutexAutoLock lock(*sHolderLock);
  86     sTrackersHolders[mSerial] = this;
  87   }
  88 }
  89
  90 AsyncTransactionTrackersHolder::~AsyncTransactionTrackersHolder()
  91 {
  92   if (!mIsTrackersHolderDestroyed) {
  93     DestroyAsyncTransactionTrackersHolder();
  94   }
  95
  96   {
  97     if (sHolderLock) {
  98       sHolderLock->Lock();
  99     }
 100     sTrackersHolders.erase(mSerial);
 101     if (sHolderLock) {
 102       sHolderLock->Unlock();
 103     }
 104   }
 105   MOZ_COUNT_DTOR(AsyncTransactionTrackersHolder);
 106 }
 107
 108 void
 109 AsyncTransactionTrackersHolder::HoldUntilComplete(AsyncTransactionTracker* aTransactionTracker)
 110 {
 111   if (!aTransactionTracker) {
 112     return;
 113   }
 114
 115   if (mIsTrackersHolderDestroyed && aTransactionTracker) {
 116     aTransactionTracker->NotifyComplete();
 117     return;
 118   }
 119
 120   if (aTransactionTracker) {
 121     MutexAutoLock lock(*sHolderLock);
 122     mAsyncTransactionTrackeres[aTransactionTracker->GetId()] = aTransactionTracker;
 123   }
 124 }
 125
 126 void
 127 AsyncTransactionTrackersHolder::TransactionCompleteted(uint64_t aTransactionId)
 128 {
 129   MutexAutoLock lock(*sHolderLock);
 130   TransactionCompletetedInternal(aTransactionId);
 131 }
 132
 133 void
 134 AsyncTransactionTrackersHolder::TransactionCompletetedInternal(uint64_t aTransactionId)
 135 {
 136   std::map<uint64_t, RefPtr<AsyncTransactionTracker> >::iterator it
 137     = mAsyncTransactionTrackeres.find(aTransactionId);
 138   if (it != mAsyncTransactionTrackeres.end()) {
 139     it->second->NotifyComplete();
 140     mAsyncTransactionTrackeres.erase(it);
 141   }
 142 }
 143
 144 void
 145 AsyncTransactionTrackersHolder::SetReleaseFenceHandle(FenceHandle& aReleaseFenceHandle,
 146                                                       uint64_t aTransactionId)
 147 {
 148   std::map<uint64_t, RefPtr<AsyncTransactionTracker> >::iterator it
 149     = mAsyncTransactionTrackeres.find(aTransactionId);
 150   if (it != mAsyncTransactionTrackeres.end()) {
 151     it->second->SetReleaseFenceHandle(aReleaseFenceHandle);
 152   }
 153 }
 154
 155 /*static*/ void
 156 AsyncTransactionTrackersHolder::TransactionCompleteted(uint64_t aHolderId, uint64_t aTransactionId)
 157 {
 158   MutexAutoLock lock(*sHolderLock);
 159   AsyncTransactionTrackersHolder* holder = sTrackersHolders[aHolderId];
 160   if (!holder) {
 161     return;
 162   }
 163   holder->TransactionCompletetedInternal(aTransactionId);
 164 }
 165
 166 /*static*/ void
 167 AsyncTransactionTrackersHolder::SetReleaseFenceHandle(FenceHandle& aReleaseFenceHandle,
 168                                                       uint64_t aHolderId,
 169                                                       uint64_t aTransactionId)
 170 {
 171   MutexAutoLock lock(*sHolderLock);
 172   AsyncTransactionTrackersHolder* holder = sTrackersHolders[aHolderId];
 173   if (!holder) {
 174     return;
 175   }
 176   holder->SetReleaseFenceHandle(aReleaseFenceHandle, aTransactionId);
 177 }
 178
 179 void
 180 AsyncTransactionTrackersHolder::ClearAllAsyncTransactionTrackers()
 181 {
 182   if (sHolderLock) {
 183     sHolderLock->Lock();
 184   }
 185   std::map<uint64_t, RefPtr<AsyncTransactionTracker> >::iterator it;
 186   for (it = mAsyncTransactionTrackeres.begin();
 187        it != mAsyncTransactionTrackeres.end(); it++) {
 188     it->second->NotifyCancel();
 189   }
 190   mAsyncTransactionTrackeres.clear();
 191   if (sHolderLock) {
 192     sHolderLock->Unlock();
 193   }
 194 }
 195
 196 void
 197 AsyncTransactionTrackersHolder::DestroyAsyncTransactionTrackersHolder() {
 198   mIsTrackersHolderDestroyed = true;
 199   ClearAllAsyncTransactionTrackers();
 200 }
 201
 202
 203 } // namespace layers
 204 } // namespace mozilla