Delete method MessageQueue::set_socketserver

webrtc/base/messagequeue.cc

 /*
  *  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.
  */
 #include <algorithm>
@@ skipping 128 matching lines @@
     }
     ~ScopedIncrement() override { AtomicOps::Decrement(value_); }
 
    private:
     volatile int* value_;
   };
 
   {
     DebugNonReentrantCritScope cs(&crit_, &locked_);
     for (MessageQueue* queue : message_queues_) {
-      if (!queue->IsProcessingMessages()) {
-        // If the queue is not processing messages, it can
+      if (!queue->IsProcessingMessages() || queue->empty()) {
+        // If the queue is empty or not processing messages, it can
         // be ignored. If we tried to post a message to it, it would be dropped
         // or ignored.
         continue;
       }
       queue->PostDelayed(RTC_FROM_HERE, 0, nullptr, MQID_DISPOSE,
                          new ScopedIncrement(&queues_not_done));
     }
   }
   // Note: One of the message queues may have been on this thread, which is why
   // we can't synchronously wait for queues_not_done to go to 0; we need to
@@ skipping 48 matching lines @@
   }
 
   fDestroyed_ = true;
   // The signal is done from here to ensure
   // that it always gets called when the queue
   // is going away.
   SignalQueueDestroyed();
   MessageQueueManager::Remove(this);
   Clear(nullptr);
 
-  SharedScope ss(&ss_lock_);
   if (ss_) {
     ss_->SetMessageQueue(nullptr);
   }
 }
 
 SocketServer* MessageQueue::socketserver() {
-  SharedScope ss(&ss_lock_);
   return ss_;
 }
 
-void MessageQueue::set_socketserver(SocketServer* ss) {
-  // Need to lock exclusively here to prevent simultaneous modifications from
-  // other threads. Can't be a shared lock to prevent races with other reading
-  // threads.
-  // Other places that only read "ss_" can use a shared lock as simultaneous
-  // read access is allowed.
-  ExclusiveScope es(&ss_lock_);
-  ss_ = ss ? ss : own_ss_.get();
-  ss_->SetMessageQueue(this);
-}
-
 void MessageQueue::WakeUpSocketServer() {
-  SharedScope ss(&ss_lock_);
   ss_->WakeUp();
 }
 
 void MessageQueue::Quit() {
   AtomicOps::ReleaseStore(&stop_, 1);
   WakeUpSocketServer();
 }
 
 bool MessageQueue::IsQuitting() {
   return AtomicOps::AcquireLoad(&stop_) != 0;
@@ skipping 97 matching lines @@
     if (cmsWait == kForever) {
       cmsNext = cmsDelayNext;
     } else {
       cmsNext = std::max<int64_t>(0, cmsTotal - cmsElapsed);
       if ((cmsDelayNext != kForever) && (cmsDelayNext < cmsNext))
         cmsNext = cmsDelayNext;
     }
 
     {
       // Wait and multiplex in the meantime
-      SharedScope ss(&ss_lock_);
       if (!ss_->Wait(static_cast<int>(cmsNext), process_io))
         return false;
     }
 
     // If the specified timeout expired, return
 
     msCurrent = TimeMillis();
     cmsElapsed = TimeDiff(msCurrent, msStart);
     if (cmsWait != kForever) {
       if (cmsElapsed >= cmsWait)
@@ skipping 167 matching lines @@
   pmsg->phandler->OnMessage(pmsg);
   int64_t end_time = TimeMillis();
   int64_t diff = TimeDiff(end_time, start_time);
   if (diff >= kSlowDispatchLoggingThreshold) {
     LOG(LS_INFO) << "Message took " << diff << "ms to dispatch. Posted from: "
                  << pmsg->posted_from.ToString();
   }
 }
 
 }  // namespace rtc