Add thread check to ModuleProcessThread::DeRegisterModule

webrtc/modules/utility/source/process_thread_impl.cc

 /*
  *  Copyright (c) 2012 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.
  */
 
@@ skipping 49 matching lines @@
 }
 
 void ProcessThreadImpl::Start() {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RTC_DCHECK(!thread_.get());
   if (thread_.get())
     return;
 
   RTC_DCHECK(!stop_);
 
-  {
-    // TODO(tommi): Since DeRegisterModule is currently being called from
-    // different threads in some cases (ChannelOwner), we need to lock access to
-    // the modules_ collection even on the controller thread.
-    // Once we've cleaned up those places, we can remove this lock.
-    rtc::CritScope lock(&lock_);
-    for (ModuleCallback& m : modules_)
-      m.module->ProcessThreadAttached(this);
-  }
+  for (ModuleCallback& m : modules_)
+    m.module->ProcessThreadAttached(this);
 
   thread_.reset(
       new rtc::PlatformThread(&ProcessThreadImpl::Run, this, thread_name_));
   thread_->Start();
 }
 
 void ProcessThreadImpl::Stop() {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if(!thread_.get())
     return;
 
   {
     rtc::CritScope lock(&lock_);
     stop_ = true;
   }
 
   wake_up_->Set();
 
   thread_->Stop();
   stop_ = false;
 
-  // TODO(tommi): Since DeRegisterModule is currently being called from
-  // different threads in some cases (ChannelOwner), we need to lock access to
-  // the modules_ collection even on the controller thread.
-  // Since DeRegisterModule also checks thread_, we also need to hold the
-  // lock for the .reset() operation.
-  // Once we've cleaned up those places, we can remove this lock.
-  rtc::CritScope lock(&lock_);
   thread_.reset();
   for (ModuleCallback& m : modules_)
     m.module->ProcessThreadAttached(nullptr);
 }
 
 void ProcessThreadImpl::WakeUp(Module* module) {
   // Allowed to be called on any thread.
   {
     rtc::CritScope lock(&lock_);
     for (ModuleCallback& m : modules_) {
@@ skipping 38 matching lines @@
     modules_.push_back(ModuleCallback(module, from));
   }
 
   // Wake the thread calling ProcessThreadImpl::Process() to update the
   // waiting time. The waiting time for the just registered module may be
   // shorter than all other registered modules.
   wake_up_->Set();
 }
 
 void ProcessThreadImpl::DeRegisterModule(Module* module) {
-  // Allowed to be called on any thread.
-  // TODO(tommi): Disallow this ^^^
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RTC_DCHECK(module);
 
   {
     rtc::CritScope lock(&lock_);
     modules_.remove_if([&module](const ModuleCallback& m) {
         return m.module == module;
       });
+  }
 
-    // TODO(tommi): we currently need to hold the lock while calling out to
-    // ProcessThreadAttached.  This is to make sure that the thread hasn't been
-    // destroyed while we attach the module.  Once we can make sure
-    // DeRegisterModule isn't being called on arbitrary threads, we can move the
-    // |if (thread_.get())| check and ProcessThreadAttached() call outside the
-    // lock scope.
-
-    // Notify the module that it's been detached.
-    if (thread_.get())
-      module->ProcessThreadAttached(nullptr);
-  }
+  // Notify the module that it's been detached.
+  module->ProcessThreadAttached(nullptr);
 }
 
 // static
 bool ProcessThreadImpl::Run(void* obj) {
   return static_cast<ProcessThreadImpl*>(obj)->Process();
 }
 
 bool ProcessThreadImpl::Process() {
   TRACE_EVENT1("webrtc", "ProcessThreadImpl", "name", thread_name_);
   int64_t now = rtc::TimeMillis();
@@ skipping 40 matching lines @@
     }
   }
 
   int64_t time_to_wait = next_checkpoint - rtc::TimeMillis();
   if (time_to_wait > 0)
     wake_up_->Wait(static_cast<unsigned long>(time_to_wait));
 
   return true;
 }
 }  // namespace webrtc