TrackObserver DCHECK not on main thread, tests updated.

content/renderer/media/webrtc/track_observer.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/media/webrtc/track_observer.h"
 
 #include "base/bind.h"
 #include "base/location.h"
-#include "base/threading/thread_checker.h"
 
 namespace content {
 
 class CONTENT_EXPORT TrackObserver::TrackObserverImpl
     : public base::RefCountedThreadSafe<TrackObserver::TrackObserverImpl>,
       NON_EXPORTED_BASE(public webrtc::ObserverInterface) {
  public:
   TrackObserverImpl(
       const scoped_refptr<base::SingleThreadTaskRunner>& main_thread,
       const scoped_refptr<webrtc::MediaStreamTrackInterface>& track)
       : main_thread_(main_thread), track_(track) {
     // We're on the signaling thread.
+    DCHECK(!main_thread_->BelongsToCurrentThread());
     track->RegisterObserver(this);
   }
 
   const scoped_refptr<webrtc::MediaStreamTrackInterface>& track() const {
     return track_;
   }
 
   const scoped_refptr<base::SingleThreadTaskRunner> main_thread() const {
     return main_thread_;
   }
@@ skipping 26 matching lines @@
   }
 
  private:
   friend class base::RefCountedThreadSafe<TrackObserverImpl>;
   ~TrackObserverImpl() override {
     DCHECK(!track_.get()) << "must have been unregistered before deleting";
   }
 
   // webrtc::ObserverInterface implementation.
   void OnChanged() override {
-    DCHECK(signaling_thread_.CalledOnValidThread());
+    DCHECK(!main_thread_->BelongsToCurrentThread());
     webrtc::MediaStreamTrackInterface::TrackState state = track_->state();
     main_thread_->PostTask(FROM_HERE,
         base::Bind(&TrackObserverImpl::OnChangedOnMainThread, this, state));
   }
 
   void OnChangedOnMainThread(
       webrtc::MediaStreamTrackInterface::TrackState state) {
     DCHECK(main_thread_->BelongsToCurrentThread());
     if (!callback_.is_null())
       callback_.Run(state);
   }
 
   const scoped_refptr<base::SingleThreadTaskRunner> main_thread_;
   scoped_refptr<webrtc::MediaStreamTrackInterface> track_;
   OnChangedCallback callback_;  // Only touched on the main thread.
-  base::ThreadChecker signaling_thread_;
 };
 
 TrackObserver::TrackObserver(
     const scoped_refptr<base::SingleThreadTaskRunner>& main_thread,
     const scoped_refptr<webrtc::MediaStreamTrackInterface>& track)
     : observer_(new TrackObserverImpl(main_thread, track)) {
 }
 
 TrackObserver::~TrackObserver() {
   // Explicitly unregister before releasing our reference.
   // We do this to avoid a race that could happen if we try to unregister
   // inside the dtor of the observer and then receive an event that causes
   // the ref count to go up while being destroyed.
   observer_->Unregister();
 }
 
 void TrackObserver::SetCallback(const OnChangedCallback& callback) {
   DCHECK(observer_->main_thread()->BelongsToCurrentThread());
   observer_->SetCallback(callback);
 }
 
 const scoped_refptr<webrtc::MediaStreamTrackInterface>&
 TrackObserver::track() const {
   return observer_->track();
 }
 
 }  // namespace content