Make sure ReadyStateEnded is fired when video stream stops

content/renderer/media/media_stream_video_capturer_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/media_stream_video_capturer_source.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "content/renderer/media/video_capture_impl_manager.h"
@@ skipping 80 matching lines @@
   manager->GetDeviceFormatsInUse(
       session_id_,
       media::BindToCurrentLoop(
           base::Bind(
               &VideoCapturerDelegate::OnDeviceFormatsInUseReceived, this)));
 }
 
 void VideoCapturerDelegate::StartCapture(
     const media::VideoCaptureParams& params,
     const VideoCaptureDeliverFrameCB& new_frame_callback,
-    const StartedCallback& started_callback) {
+    const RunningCallback& running_callback) {
   DCHECK(params.requested_format.IsValid());
   DCHECK(thread_checker_.CalledOnValidThread());
-  started_callback_ = started_callback;
+  running_callback_ = running_callback;
   got_first_frame_ = false;
 
   // NULL in unit test.
   if (!RenderThreadImpl::current())
     return;
   VideoCaptureImplManager* manager =
       RenderThreadImpl::current()->video_capture_impl_manager();
   if (!manager)
     return;
   stop_capture_cb_ =
       manager->StartCapture(
           session_id_,
           params,
           media::BindToCurrentLoop(base::Bind(
               &VideoCapturerDelegate::OnStateUpdateOnRenderThread, this)),
           new_frame_callback);
 }
 
 void VideoCapturerDelegate::StopCapture() {
   // Immediately make sure we don't provide more frames.
   DVLOG(3) << "VideoCapturerDelegate::StopCapture()";
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!stop_capture_cb_.is_null()) {
     base::ResetAndReturn(&stop_capture_cb_).Run();
   }
-  started_callback_.Reset();
+  running_callback_.Reset();
   source_formats_callback_.Reset();
 }
 
 void VideoCapturerDelegate::OnStateUpdateOnRenderThread(
     VideoCaptureState state) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(3) << "OnStateUpdateOnRenderThread state = " << state;
-  if (state > VIDEO_CAPTURE_STATE_STARTING && !started_callback_.is_null()) {
-    base::ResetAndReturn(&started_callback_).Run(
-        state == VIDEO_CAPTURE_STATE_STARTED);
+  if (state == VIDEO_CAPTURE_STATE_STARTED && !running_callback_.is_null()) {
+    running_callback_.Run(true);
+    return;
+  }
+  if (state > VIDEO_CAPTURE_STATE_STARTED && !running_callback_.is_null()) {
+    base::ResetAndReturn(&running_callback_).Run(false);
   }
 }
 
 void VideoCapturerDelegate::OnDeviceFormatsInUseReceived(
     const media::VideoCaptureFormats& formats_in_use) {
   DVLOG(3) << "OnDeviceFormatsInUseReceived: " << formats_in_use.size();
   DCHECK(thread_checker_.CalledOnValidThread());
   // StopCapture() might have destroyed |source_formats_callback_| before
   // arriving here.
   if (source_formats_callback_.is_null())
@@ skipping 82 matching lines @@
       frame_callback,
       base::Bind(&MediaStreamVideoCapturerSource::OnStartDone,
                  base::Unretained(this)));
 }
 
 void MediaStreamVideoCapturerSource::StopSourceImpl() {
   delegate_->StopCapture();
 }
 
 }  // namespace content