Change DtmfSenderHandler to handle events on the signaling thread.

content/renderer/media/webrtc/media_stream_remote_video_source.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/media_stream_remote_video_source.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
 #include "base/location.h"
@@ skipping 113 matching lines @@
     const media::VideoCaptureFormat& format) {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
   TRACE_EVENT0("webrtc", "RemoteVideoSourceDelegate::DoRenderFrameOnIOThread");
   // TODO(hclam): Give the estimated capture time.
   frame_callback_.Run(video_frame, format, base::TimeTicks());
 }
 
 MediaStreamRemoteVideoSource::Observer::Observer(
     const scoped_refptr<base::SingleThreadTaskRunner>& main_thread,
     webrtc::VideoTrackInterface* track)
-    : main_thread_(main_thread), track_(track), state_(track->state()) {
+    : main_thread_(main_thread),
+      source_set_(false),
+      track_(track),
+      state_(track->state()) {
   track->RegisterObserver(this);
 }
 
 const scoped_refptr<webrtc::VideoTrackInterface>&
 MediaStreamRemoteVideoSource::Observer::track() {
   DCHECK(main_thread_->BelongsToCurrentThread());
   return track_;
 }
 
 webrtc::MediaStreamTrackInterface::TrackState
 MediaStreamRemoteVideoSource::Observer::state() const {
   DCHECK(main_thread_->BelongsToCurrentThread());
   return state_;
 }
 
 MediaStreamRemoteVideoSource::Observer::~Observer() {
   DCHECK(main_thread_->BelongsToCurrentThread());
   track_->UnregisterObserver(this);
 }
 
 void MediaStreamRemoteVideoSource::Observer::SetSource(
     const base::WeakPtr<MediaStreamRemoteVideoSource>& source) {
   DCHECK(main_thread_->BelongsToCurrentThread());
   DCHECK(!source_);
+  DLOG(ERROR) << "SetSource";

[tommi (sloooow) - chröme, 2014/11/03 13:49:56]

remove? (and the rest of the debug logging)

[perkj_chrome, 2014/11/03 14:53:33]

sorry....

   source_ = source;
+  // |source_set_| means that there is a MediaStreamRemoteVideoSource that
+  // should handle all state changes. Since an Observer is always created when
+  // a remote MediaStream changes in RemoteMediaStreamImpl::Observer::OnChanged,
+  // it can happen that an Observer is created but SetSource is never called.
+  source_set_ = true;
 }
 
 void MediaStreamRemoteVideoSource::Observer::OnChanged() {
   webrtc::MediaStreamTrackInterface::TrackState state = track_->state();
+  DLOG(ERROR) << ":Observer::OnChanged" << state;
   main_thread_->PostTask(FROM_HERE,
       base::Bind(&MediaStreamRemoteVideoSource::Observer::OnChangedImpl,
           this, state));
 }
 
 void MediaStreamRemoteVideoSource::Observer::OnChangedImpl(
     webrtc::MediaStreamTrackInterface::TrackState state) {
   DCHECK(main_thread_->BelongsToCurrentThread());
-  DCHECK(source_) << "Dropping a state change event. " << state;
+  DCHECK(source_ || !source_set_) << "Dropping a state change event. " << state;
   if (source_ && state != state_)
     source_->OnChanged(state);
   state_ = state;
 }
 
 MediaStreamRemoteVideoSource::MediaStreamRemoteVideoSource(
     const scoped_refptr<MediaStreamRemoteVideoSource::Observer>& observer)
     : observer_(observer), weak_factory_(this) {
   observer->SetSource(weak_factory_.GetWeakPtr());
+  DLOG(ERROR) << "MediaStreamRemoteVideoSource";
 }
 
 MediaStreamRemoteVideoSource::~MediaStreamRemoteVideoSource() {
+  DLOG(ERROR) << "~MediaStreamRemoteVideoSource";
   DCHECK(CalledOnValidThread());
 }
 
 void MediaStreamRemoteVideoSource::GetCurrentSupportedFormats(
     int max_requested_width,
     int max_requested_height,
     double max_requested_frame_rate,
     const VideoCaptureDeviceFormatsCB& callback) {
   DCHECK(CalledOnValidThread());
   media::VideoCaptureFormats formats;
@@ skipping 19 matching lines @@
 }
 
 webrtc::VideoRendererInterface*
 MediaStreamRemoteVideoSource::RenderInterfaceForTest() {
   return delegate_.get();
 }
 
 void MediaStreamRemoteVideoSource::OnChanged(
     webrtc::MediaStreamTrackInterface::TrackState state) {
   DCHECK(CalledOnValidThread());
+  DLOG(ERROR) << "OnChanged" << state;
   switch (state) {
     case webrtc::MediaStreamTrackInterface::kInitializing:
       // Ignore the kInitializing state since there is no match in
       // WebMediaStreamSource::ReadyState.
       break;
     case webrtc::MediaStreamTrackInterface::kLive:
       SetReadyState(blink::WebMediaStreamSource::ReadyStateLive);
       break;
     case webrtc::MediaStreamTrackInterface::kEnded:
       SetReadyState(blink::WebMediaStreamSource::ReadyStateEnded);
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
 }  // namespace content