Prevent data race in MessageQueue.

webrtc/base/messagequeue.h

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #ifndef WEBRTC_BASE_MESSAGEQUEUE_H_
 #define WEBRTC_BASE_MESSAGEQUEUE_H_
 
 #include <string.h>
 
 #include <algorithm>
 #include <list>
 #include <queue>
 #include <vector>
 
 #include "webrtc/base/basictypes.h"
 #include "webrtc/base/constructormagic.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/messagehandler.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/scoped_ref_ptr.h"
+#include "webrtc/base/sharedexclusivelock.h"
 #include "webrtc/base/sigslot.h"
 #include "webrtc/base/socketserver.h"
 #include "webrtc/base/timeutils.h"
+#include "webrtc/base/thread_annotations.h"
 
 namespace rtc {
 
 struct Message;
 class MessageQueue;
 
 // MessageQueueManager does cleanup of of message queues
 
 class MessageQueueManager {
  public:
@@ skipping 134 matching lines @@
   // being created.
   explicit MessageQueue(SocketServer* ss = NULL,
                         bool init_queue = true);
 
   // NOTE: SUBCLASSES OF MessageQueue THAT OVERRIDE Clear MUST CALL
   // DoDestroy() IN THEIR DESTRUCTORS! This is required to avoid a data race
   // between the destructor modifying the vtable, and the MessageQueueManager
   // calling Clear on the object from a different thread.
   virtual ~MessageQueue();
 
-  SocketServer* socketserver() { return ss_; }
+  SocketServer* socketserver();
   void set_socketserver(SocketServer* ss);
 
   // Note: The behavior of MessageQueue has changed.  When a MQ is stopped,
   // futher Posts and Sends will fail.  However, any pending Sends and *ready*
   // Posts (as opposed to unexpired delayed Posts) will be delivered before
   // Get (or Peek) returns false.  By guaranteeing delivery of those messages,
   // we eliminate the race condition when an MessageHandler and MessageQueue
   // may be destroyed independently of each other.
   virtual void Quit();
   virtual bool IsQuitting();
@@ skipping 58 matching lines @@
                    MessageData* pdata);
 
   // Perform initialization, subclasses must call this from their constructor
   // if false was passed as init_queue to the MessageQueue constructor.
   void DoInit();
 
   // Perform cleanup, subclasses that override Clear must call this from the
   // destructor.
   void DoDestroy();
 
-  // The SocketServer is not owned by MessageQueue.
-  SocketServer* ss_;
-  // If a server isn't supplied in the constructor, use this one.
-  scoped_ptr<SocketServer> default_ss_;
+  void WakeUpSocketServer();
+
   bool fStop_;
   bool fPeekKeep_;
   Message msgPeek_;
-  MessageList msgq_;
-  PriorityQueue dmsgq_;
-  uint32_t dmsgq_next_num_;
+  MessageList msgq_ GUARDED_BY(crit_);
+  PriorityQueue dmsgq_ GUARDED_BY(crit_);
+  uint32_t dmsgq_next_num_ GUARDED_BY(crit_);
   CriticalSection crit_;
   bool fInitialized_;
   bool fDestroyed_;
 
  private:
+  // The SocketServer is not owned by MessageQueue.
+  SocketServer* ss_ GUARDED_BY(ss_lock_);
+  // If a server isn't supplied in the constructor, use this one.
+  scoped_ptr<SocketServer> default_ss_;
+  SharedExclusiveLock ss_lock_;
+
   RTC_DISALLOW_COPY_AND_ASSIGN(MessageQueue);
 };
 
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_MESSAGEQUEUE_H_