MessageQueue uses Deque<OwnPtr<> >

Source/wtf/MessageQueue.h

 /*
  * Copyright (C) 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 16 matching lines @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef MessageQueue_h
 #define MessageQueue_h
 
 #include <limits>
 #include "wtf/Assertions.h"
 #include "wtf/Deque.h"
 #include "wtf/Noncopyable.h"
+#include "wtf/OwnPtr.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/ThreadingPrimitives.h"
 
 namespace WTF {
 
     enum MessageQueueWaitResult {
         MessageQueueTerminated,       // Queue was destroyed while waiting for message.
         MessageQueueTimeout,          // Timeout was specified and it expired.
         MessageQueueMessageReceived   // A message was successfully received and returned.
     };
 
     // The queue takes ownership of messages and transfer it to the new owner
     // when messages are fetched from the queue.
     // Essentially, MessageQueue acts as a queue of OwnPtr<DataType>.
     template<typename DataType>
     class MessageQueue {
         WTF_MAKE_NONCOPYABLE(MessageQueue);
     public:
         MessageQueue() : m_killed(false) { }
-        ~MessageQueue();
 
         // Returns true if the queue is still alive, false if the queue has been killed.
         bool append(PassOwnPtr<DataType>);
         void appendAndKill(PassOwnPtr<DataType>);
         bool appendAndCheckEmpty(PassOwnPtr<DataType>);
         void prepend(PassOwnPtr<DataType>);
 
         PassOwnPtr<DataType> waitForMessage();
         PassOwnPtr<DataType> tryGetMessage();
         PassOwnPtr<DataType> tryGetMessageIgnoringKilled();
         PassOwnPtr<DataType> waitForMessageWithTimeout(MessageQueueWaitResult&, double absoluteTime);
 
         void kill();
         bool killed() const;
 
         // The result of isEmpty() is only valid if no other thread is manipulating the queue at the same time.
         bool isEmpty();
 
         static double infiniteTime() { return std::numeric_limits<double>::max(); }
 
     private:
         mutable Mutex m_mutex;
         ThreadCondition m_condition;
-        Deque<DataType*> m_queue;
+        Deque<OwnPtr<DataType> > m_queue;
         bool m_killed;
     };
 
     template<typename DataType>
-    MessageQueue<DataType>::~MessageQueue()
-    {
-        deleteAllValues(m_queue);
-    }
-
-    template<typename DataType>
     inline bool MessageQueue<DataType>::append(PassOwnPtr<DataType> message)
     {
         MutexLocker lock(m_mutex);
-        m_queue.append(message.leakPtr());
+        m_queue.append(message);
         m_condition.signal();
         return !m_killed;
     }
 
     template<typename DataType>
     inline void MessageQueue<DataType>::appendAndKill(PassOwnPtr<DataType> message)
     {
         MutexLocker lock(m_mutex);
-        m_queue.append(message.leakPtr());
+        m_queue.append(message);
         m_killed = true;
         m_condition.broadcast();
     }
 
     // Returns true if the queue was empty before the item was added.
     template<typename DataType>
     inline bool MessageQueue<DataType>::appendAndCheckEmpty(PassOwnPtr<DataType> message)
     {
         MutexLocker lock(m_mutex);
         bool wasEmpty = m_queue.isEmpty();
-        m_queue.append(message.leakPtr());
+        m_queue.append(message);
         m_condition.signal();
         return wasEmpty;
     }
 
     template<typename DataType>
     inline void MessageQueue<DataType>::prepend(PassOwnPtr<DataType> message)
     {
         MutexLocker lock(m_mutex);
-        m_queue.prepend(message.leakPtr());
+        m_queue.prepend(message);
         m_condition.signal();
     }
 
     template<typename DataType>
     inline PassOwnPtr<DataType> MessageQueue<DataType>::waitForMessage()
     {
         MessageQueueWaitResult exitReason;
         OwnPtr<DataType> result = waitForMessageWithTimeout(exitReason, infiniteTime());
         ASSERT(exitReason == MessageQueueTerminated || exitReason == MessageQueueMessageReceived);
         return result.release();
@@ skipping 13 matching lines @@
         if (m_killed) {
             result = MessageQueueTerminated;
             return nullptr;
         }
 
         if (timedOut) {
             result = MessageQueueTimeout;
             return nullptr;
         }
 
-        DequeConstIterator<DataType*> found = m_queue.begin();
+        ASSERT_WITH_SECURITY_IMPLICATION(!m_queue.isEmpty());
+        result = MessageQueueMessageReceived;
 
-        ASSERT_WITH_SECURITY_IMPLICATION(found != m_queue.end());
-        OwnPtr<DataType> message = adoptPtr(*found);
-        m_queue.remove(found);
-        result = MessageQueueMessageReceived;
-        return message.release();
+        return m_queue.takeFirst();
     }
 
     template<typename DataType>
     inline PassOwnPtr<DataType> MessageQueue<DataType>::tryGetMessage()
     {
         MutexLocker lock(m_mutex);
         if (m_killed)
             return nullptr;
         if (m_queue.isEmpty())
             return nullptr;
 
-        return adoptPtr(m_queue.takeFirst());
+        return m_queue.takeFirst();
     }
 
     template<typename DataType>
     inline PassOwnPtr<DataType> MessageQueue<DataType>::tryGetMessageIgnoringKilled()
     {
         MutexLocker lock(m_mutex);
         if (m_queue.isEmpty())
             return nullptr;
 
-        return adoptPtr(m_queue.takeFirst());
+        return m_queue.takeFirst();
     }
 
     template<typename DataType>
     inline bool MessageQueue<DataType>::isEmpty()
     {
         MutexLocker lock(m_mutex);
         if (m_killed)
             return true;
         return m_queue.isEmpty();
     }
@@ skipping 15 matching lines @@
 } // namespace WTF
 
 using WTF::MessageQueue;
 // MessageQueueWaitResult enum and all its values.
 using WTF::MessageQueueWaitResult;
 using WTF::MessageQueueTerminated;
 using WTF::MessageQueueTimeout;
 using WTF::MessageQueueMessageReceived;
 
 #endif // MessageQueue_h