The Tor Browser: dom/workers/Queue.h@b8a032363ba2 (annotated)

dom/workers/Queue.h@b8a032363ba2 (annotated)

dom/workers/Queue.h

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #ifndef mozilla_dom_workers_queue_h__
 #define mozilla_dom_workers_queue_h__
 #include "Workers.h"
 #include "mozilla/Mutex.h"
 #include "nsTArray.h"
 BEGIN_WORKERS_NAMESPACE
 template <typename T, int TCount>
 struct StorageWithTArray
 {
   typedef nsAutoTArray<T, TCount> StorageType;
   static void Reverse(StorageType& aStorage)
   {
     uint32_t length = aStorage.Length();
     for (uint32_t index = 0; index < length / 2; index++) {
       uint32_t reverseIndex = length - 1 - index;
       T t1 = aStorage.ElementAt(index);
       T t2 = aStorage.ElementAt(reverseIndex);
       aStorage.ReplaceElementsAt(index, 1, t2);
       aStorage.ReplaceElementsAt(reverseIndex, 1, t1);
     }
   }
   static bool IsEmpty(const StorageType& aStorage)
   {
     return !!aStorage.IsEmpty();
   }
   static bool Push(StorageType& aStorage, const T& aEntry)
   {
     return !!aStorage.AppendElement(aEntry);
   }
   static bool Pop(StorageType& aStorage, T& aEntry)
   {
     if (IsEmpty(aStorage)) {
       return false;
     }
     uint32_t index = aStorage.Length() - 1;
     aEntry = aStorage.ElementAt(index);
     aStorage.RemoveElementAt(index);
     return true;
   }
   static void Clear(StorageType& aStorage)
   {
     aStorage.Clear();
   }
   static void Compact(StorageType& aStorage)
   {
     aStorage.Compact();
   }
 };
 class LockingWithMutex
 {
   mozilla::Mutex mMutex;
 protected:
   LockingWithMutex()
   : mMutex("LockingWithMutex::mMutex")
   { }
   void Lock()
   {
     mMutex.Lock();
   }
   void Unlock()
   {
     mMutex.Unlock();
   }
   class AutoLock
   {
     LockingWithMutex& mHost;
   public:
     AutoLock(LockingWithMutex& aHost)
     : mHost(aHost)
     {
       mHost.Lock();
     }
     ~AutoLock()
     {
       mHost.Unlock();
     }
   };
   friend class AutoLock;
 };
 class NoLocking
 {
 protected:
   void Lock()
   { }
   void Unlock()
   { }
   class AutoLock
   {
   public:
     AutoLock(NoLocking& aHost)
     { }
     ~AutoLock()
     { }
   };
 };
 template <typename T,
           int TCount = 256,
           class LockingPolicy = NoLocking,
           class StoragePolicy = StorageWithTArray<T, TCount % 2 ?
                                                      TCount / 2 + 1 :
                                                      TCount / 2> >
 class Queue : public LockingPolicy
 {
   typedef typename StoragePolicy::StorageType StorageType;
   typedef typename LockingPolicy::AutoLock AutoLock;
   StorageType mStorage1;
   StorageType mStorage2;
   StorageType* mFront;
   StorageType* mBack;
 public:
   Queue()
   : mFront(&mStorage1), mBack(&mStorage2)
   { }
   bool IsEmpty()
   {
     AutoLock lock(*this);
     return StoragePolicy::IsEmpty(*mFront) &&
            StoragePolicy::IsEmpty(*mBack);
   }
   bool Push(const T& aEntry)
   {
     AutoLock lock(*this);
     return StoragePolicy::Push(*mBack, aEntry);
   }
   bool Pop(T& aEntry)
   {
     AutoLock lock(*this);
     if (StoragePolicy::IsEmpty(*mFront)) {
       StoragePolicy::Compact(*mFront);
       StoragePolicy::Reverse(*mBack);
       StorageType* tmp = mFront;
       mFront = mBack;
       mBack = tmp;
     }
     return StoragePolicy::Pop(*mFront, aEntry);
   }
   void Clear()
   {
     AutoLock lock(*this);
     StoragePolicy::Clear(*mFront);
     StoragePolicy::Clear(*mBack);
   }
   // XXX Do we need this?
   void Lock()
   {
     LockingPolicy::Lock();
   }
   // XXX Do we need this?
   void Unlock()
   {
     LockingPolicy::Unlock();
   }
 private:
   // Queue is not copyable.
   Queue(const Queue&);
   Queue & operator=(const Queue&);
 };
 END_WORKERS_NAMESPACE
 #endif /* mozilla_dom_workers_queue_h__ */

The Tor Browser / annotate

dom/workers/Queue.h@b8a032363ba2 (annotated)

dom/workers/Queue.h