Update MediaStreamTrack::Stop to latest draft.

content/renderer/media/media_stream_impl.cc

 // Copyright (c) 2012 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_impl.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
@@ skipping 324 matching lines @@
                     request_info);
 
   blink::WebString webkit_id = base::UTF8ToUTF16(label);
   blink::WebMediaStream* web_stream = &(request_info->web_stream);
 
   web_stream->initialize(webkit_id, audio_track_vector,
                          video_track_vector);
   web_stream->setExtraData(
       new MediaStream(
           dependency_factory_,
-          base::Bind(&MediaStreamImpl::OnLocalMediaStreamStop, AsWeakPtr()),
           *web_stream));
 
   // Wait for the tracks to be started successfully or to fail.
   request_info->CallbackOnTracksStarted(
       base::Bind(&MediaStreamImpl::OnCreateNativeTracksCompleted, AsWeakPtr()));
 }
 
 // Callback from MediaStreamDispatcher.
 // The requested stream failed to be generated.
 void MediaStreamImpl::OnStreamGenerationFailed(
     int request_id,
     content::MediaStreamRequestResult result) {
   DCHECK(CalledOnValidThread());
   DVLOG(1) << "MediaStreamImpl::OnStreamGenerationFailed("
            << request_id << ")";
   UserMediaRequestInfo* request_info = FindUserMediaRequestInfo(request_id);
   if (!request_info) {
     // This can happen if the request is canceled or the frame reloads while
     // MediaStreamDispatcher is processing the request.
     DVLOG(1) << "Request ID not found";
     return;
   }
-  CompleteGetUserMediaRequest(request_info->web_stream,
-                              &request_info->request,
-                              result);
+
+  GetUserMediaRequestFailed(&request_info->request, result);
   DeleteUserMediaRequestInfo(request_info);
 }
 
 // Callback from MediaStreamDispatcher.
 // The browser process has stopped a device used by a MediaStream.
 void MediaStreamImpl::OnDeviceStopped(
     const std::string& label,
     const StreamDeviceInfo& device_info) {
   DCHECK(CalledOnValidThread());
   DVLOG(1) << "MediaStreamImpl::OnDeviceStopped("
@@ skipping 11 matching lines @@
   blink::WebMediaStreamSource source(*source_ptr);
   StopLocalSource(source, false);
 
   for (LocalStreamSources::iterator device_it = local_sources_.begin();
        device_it != local_sources_.end(); ++device_it) {
     if (device_it->source.id() == source.id()) {
       local_sources_.erase(device_it);
       break;
     }
   }
-
-  // Remove the reference to this source from all |user_media_requests_|.
-  // TODO(perkj): The below is not necessary once we don't need to support
-  // MediaStream::Stop().
-  UserMediaRequests::iterator it = user_media_requests_.begin();
-  while (it != user_media_requests_.end()) {
-    (*it)->RemoveSource(source);
-    if ((*it)->AreAllSourcesRemoved()) {
-      it = user_media_requests_.erase(it);
-    } else {
-      ++it;
-    }
-  }
 }
 
 void MediaStreamImpl::InitializeSourceObject(
     const StreamDeviceInfo& device,
     blink::WebMediaStreamSource::Type type,
     const blink::WebMediaConstraints& constraints,
     blink::WebFrame* frame,
     blink::WebMediaStreamSource* webkit_source) {
   const blink::WebMediaStreamSource* existing_source =
       FindLocalSource(device);
@@ skipping 101 matching lines @@
     request->StartAudioTrack((*webkit_tracks)[i], constraints);
   }
 }
 
 void MediaStreamImpl::OnCreateNativeTracksCompleted(
     UserMediaRequestInfo* request,
     content::MediaStreamRequestResult result) {
   DVLOG(1) << "MediaStreamImpl::OnCreateNativeTracksComplete("
            << "{request_id = " << request->request_id << "} "
            << "{result = " << result << "})";
-  CompleteGetUserMediaRequest(request->web_stream, &request->request,
-                              result);
-  if (result != MEDIA_DEVICE_OK) {
-    // TODO(perkj): Once we don't support MediaStream::Stop the |request_info|
-    // can be deleted even if the request succeeds.
-    DeleteUserMediaRequestInfo(request);
-    StopUnreferencedSources(true);
-  }
+  if (result == content::MEDIA_DEVICE_OK)
+    GetUserMediaRequestSucceeded(request->web_stream, &request->request);
+  else
+    GetUserMediaRequestFailed(&request->request, result);
+
+  DeleteUserMediaRequestInfo(request);

[tommi (sloooow) - chröme, 2014/04/03 08:53:16]

Previously we didn't delete the request on success. Was that a bug?

[perkj_chrome, 2014/04/03 11:58:34]

No- We kept it all the time since we needed to support MediaStream::Stop that
worked differently from MediaStreamTrack::Stop. Now I implement
MediaStream::Stop and simply looping through all tracks in the mediastream and
call MediaStreamTrack::Stop.

 }
 
 void MediaStreamImpl::OnDevicesEnumerated(
     int request_id,
     const StreamDeviceInfoArray& device_array) {
   DVLOG(1) << "MediaStreamImpl::OnDevicesEnumerated("
            << request_id << ")";
   NOTIMPLEMENTED();
 }
 
 void MediaStreamImpl::OnDeviceOpened(
     int request_id,
     const std::string& label,
     const StreamDeviceInfo& video_device) {
   DVLOG(1) << "MediaStreamImpl::OnDeviceOpened("
            << request_id << ", " << label << ")";
   NOTIMPLEMENTED();
 }
 
 void MediaStreamImpl::OnDeviceOpenFailed(int request_id) {
   DVLOG(1) << "MediaStreamImpl::VideoDeviceOpenFailed("
            << request_id << ")";
   NOTIMPLEMENTED();
 }
 
-void MediaStreamImpl::CompleteGetUserMediaRequest(
+void MediaStreamImpl::GetUserMediaRequestSucceeded(
     const blink::WebMediaStream& stream,
+    blink::WebUserMediaRequest* request_info) {
+  DVLOG(1) << "MediaStreamImpl::GetUserMediaRequestSucceeded";
+  request_info->requestSucceeded(stream);
+}
+
+void MediaStreamImpl::GetUserMediaRequestFailed(
     blink::WebUserMediaRequest* request_info,
     content::MediaStreamRequestResult result) {
-
-  DVLOG(1) << "MediaStreamImpl::CompleteGetUserMediaRequest("
-           << "result=" << result;
-
   switch (result) {
     case MEDIA_DEVICE_OK:
-      request_info->requestSucceeded(stream);
+      NOTREACHED();
       break;
     case MEDIA_DEVICE_PERMISSION_DENIED:
       request_info->requestDenied();
       break;
     case MEDIA_DEVICE_PERMISSION_DISMISSED:
       request_info->requestFailedUASpecific("PermissionDismissedError");
       break;
     case MEDIA_DEVICE_INVALID_STATE:
       request_info->requestFailedUASpecific("InvalidStateError");
       break;
@@ skipping 30 matching lines @@
     const StreamDeviceInfo& active_device = source->device_info();
     if (active_device.device.id == device.device.id &&
         active_device.device.type == device.device.type &&
         active_device.session_id == device.session_id) {
       return &it->source;
     }
   }
   return NULL;
 }
 
-bool MediaStreamImpl::IsSourceInRequests(
-    const blink::WebMediaStreamSource& source) const {
-  for (UserMediaRequests::const_iterator req_it = user_media_requests_.begin();
-       req_it != user_media_requests_.end(); ++req_it) {
-    if ((*req_it)->IsSourceUsed(source))
-      return true;
-  }
-  return false;
-}
-
 MediaStreamImpl::UserMediaRequestInfo*
 MediaStreamImpl::FindUserMediaRequestInfo(int request_id) {
   UserMediaRequests::iterator it = user_media_requests_.begin();
   for (; it != user_media_requests_.end(); ++it) {
     if ((*it)->request_id == request_id)
       return (*it);
   }
   return NULL;
 }
 
 MediaStreamImpl::UserMediaRequestInfo*
 MediaStreamImpl::FindUserMediaRequestInfo(
     const blink::WebUserMediaRequest& request) {
   UserMediaRequests::iterator it = user_media_requests_.begin();
   for (; it != user_media_requests_.end(); ++it) {
     if ((*it)->request == request)
       return (*it);
   }
   return NULL;
 }
 
-MediaStreamImpl::UserMediaRequestInfo*
-MediaStreamImpl::FindUserMediaRequestInfo(const std::string& label) {
-  UserMediaRequests::iterator it = user_media_requests_.begin();
-  for (; it != user_media_requests_.end(); ++it) {
-    if ((*it)->generated && (*it)->web_stream.id() == base::UTF8ToUTF16(label))
-      return (*it);
-  }
-  return NULL;
-}
-
 void MediaStreamImpl::DeleteUserMediaRequestInfo(
     UserMediaRequestInfo* request) {
   UserMediaRequests::iterator it = user_media_requests_.begin();
   for (; it != user_media_requests_.end(); ++it) {
     if ((*it) == request) {
       user_media_requests_.erase(it);
       return;
     }
   }
   NOTREACHED();
@@ skipping 32 matching lines @@
   while (sources_it != local_sources_.end()) {
     if (sources_it->frame == frame) {
       StopLocalSource(sources_it->source, true);
       sources_it = local_sources_.erase(sources_it);
     } else {
       ++sources_it;
     }
   }
 }
 
-void MediaStreamImpl::OnLocalMediaStreamStop(
-    const std::string& label) {
-  DVLOG(1) << "MediaStreamImpl::OnLocalMediaStreamStop(" << label << ")";
-
-  UserMediaRequestInfo* user_media_request = FindUserMediaRequestInfo(label);
-  if (user_media_request) {
-    DeleteUserMediaRequestInfo(user_media_request);
-  }
-  StopUnreferencedSources(true);
-}
-
 void MediaStreamImpl::OnLocalSourceStopped(
     const blink::WebMediaStreamSource& source) {
   DCHECK(CalledOnValidThread());
+  DVLOG(1) << "MediaStreamImpl::OnLocalSourceStopped";
 
   bool device_found = false;
   for (LocalStreamSources::iterator device_it = local_sources_.begin();
        device_it != local_sources_.end(); ++device_it) {
     if (device_it->source.id()  == source.id()) {
       device_found = true;
       local_sources_.erase(device_it);
       break;
     }
   }
   CHECK(device_found);
 
-  // Remove the reference to this source from all |user_media_requests_|.
-  // TODO(perkj): The below is not necessary once we don't need to support
-  // MediaStream::Stop().
-  UserMediaRequests::iterator it = user_media_requests_.begin();
-  while (it != user_media_requests_.end()) {
-    (*it)->RemoveSource(source);
-    if ((*it)->AreAllSourcesRemoved()) {
-      it = user_media_requests_.erase(it);
-    } else {
-      ++it;
-    }
-  }
-
   MediaStreamSource* source_impl =
       static_cast<MediaStreamSource*> (source.extraData());
   media_stream_dispatcher_->StopStreamDevice(source_impl->device_info());
 }
 
 void MediaStreamImpl::StopLocalSource(
     const blink::WebMediaStreamSource& source,
     bool notify_dispatcher) {
   MediaStreamSource* source_impl =
       static_cast<MediaStreamSource*> (source.extraData());
   DVLOG(1) << "MediaStreamImpl::StopLocalSource("
            << "{device_id = " << source_impl->device_info().device.id << "})";
 
   if (notify_dispatcher)
     media_stream_dispatcher_->StopStreamDevice(source_impl->device_info());
 
   source_impl->ResetSourceStoppedCallback();
   source_impl->StopSource();
 }
 
-void MediaStreamImpl::StopUnreferencedSources(bool notify_dispatcher) {
-  LocalStreamSources::iterator source_it = local_sources_.begin();
-  while (source_it != local_sources_.end()) {
-    if (!IsSourceInRequests(source_it->source)) {
-      StopLocalSource(source_it->source, notify_dispatcher);
-      source_it = local_sources_.erase(source_it);
-    } else {
-      ++source_it;
-    }
-  }
-}
-
 scoped_refptr<WebRtcAudioRenderer> MediaStreamImpl::CreateRemoteAudioRenderer(
     webrtc::MediaStreamInterface* stream,
     int render_frame_id) {
   if (stream->GetAudioTracks().empty())
     return NULL;
 
   DVLOG(1) << "MediaStreamImpl::CreateRemoteAudioRenderer label:"
            << stream->label();
 
   // TODO(tommi): Change the default value of session_id to be
@@ skipping 147 matching lines @@
            sources_.begin();
        it != sources_.end(); ++it) {
     if (source.id() == it->id()) {
       sources_.erase(it);
       return;
     }
   }
 }
 
 }  // namespace content