Adds MediaStreamSource, MediaStreamAudioSource and MediaStreamVideoCaptureDeviceSource

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"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/renderer/media/media_stream_audio_renderer.h"
+#include "content/renderer/media/media_stream_audio_source.h"
 #include "content/renderer/media/media_stream_dependency_factory.h"
 #include "content/renderer/media/media_stream_dispatcher.h"
 #include "content/renderer/media/media_stream_extra_data.h"
-#include "content/renderer/media/media_stream_source_extra_data.h"
+#include "content/renderer/media/media_stream_video_capturer_source.h"
 #include "content/renderer/media/peer_connection_tracker.h"
 #include "content/renderer/media/rtc_video_renderer.h"
 #include "content/renderer/media/webrtc_audio_capturer.h"
 #include "content/renderer/media/webrtc_audio_renderer.h"
 #include "content/renderer/media/webrtc_local_audio_renderer.h"
 #include "content/renderer/media/webrtc_logging.h"
 #include "content/renderer/media/webrtc_uma_histograms.h"
 #include "content/renderer/render_thread_impl.h"
 #include "media/base/audio_hardware_config.h"
 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
@@ skipping 38 matching lines @@
 
 void GetDefaultOutputDeviceParams(
     int* output_sample_rate, int* output_buffer_size) {
   // Fetch the default audio output hardware config.
   media::AudioHardwareConfig* hardware_config =
       RenderThreadImpl::current()->GetAudioHardwareConfig();
   *output_sample_rate = hardware_config->GetOutputSampleRate();
   *output_buffer_size = hardware_config->GetOutputBufferSize();
 }
 
-void RemoveSource(const blink::WebMediaStreamSource& source,
-                  std::vector<blink::WebMediaStreamSource>* sources) {
-  for (std::vector<blink::WebMediaStreamSource>::iterator it =
-           sources->begin();
-       it != sources->end(); ++it) {
-    if (source.id() == it->id()) {
-      sources->erase(it);
-      return;
-    }
-  }
-}
-
 }  // namespace
 
 MediaStreamImpl::MediaStreamImpl(
     RenderView* render_view,
     MediaStreamDispatcher* media_stream_dispatcher,
     MediaStreamDependencyFactory* dependency_factory)
     : RenderViewObserver(render_view),
       dependency_factory_(dependency_factory),
       media_stream_dispatcher_(media_stream_dispatcher) {
 }
@@ skipping 216 matching lines @@
          device_it != video_array.end(); ++device_it) {
       if (!FindLocalSource(*device_it))
         media_stream_dispatcher_->StopStreamDevice(*device_it);
     }
 
     DVLOG(1) << "Request ID not found";
     return;
   }
   request_info->generated = true;
 
-  blink::WebVector<blink::WebMediaStreamSource> audio_source_vector(
-        audio_array.size());
-
-  // Log the device names for this request.
-  for (StreamDeviceInfoArray::const_iterator it = audio_array.begin();
-       it != audio_array.end(); ++it) {
-    WebRtcLogMessage(base::StringPrintf(
-        "Generated media stream for request id %d contains audio device name"
-        " \"%s\"",
-        request_id,
-        it->device.name.c_str()));
-  }
-
-  StreamDeviceInfoArray overridden_audio_array = audio_array;
-  if (!request_info->enable_automatic_output_device_selection) {
-    // If the GetUserMedia request did not explicitly set the constraint
-    // kMediaStreamRenderToAssociatedSink, the output device parameters must
-    // be removed.
-    for (StreamDeviceInfoArray::iterator it = overridden_audio_array.begin();
-         it != overridden_audio_array.end(); ++it) {
-      it->device.matched_output_device_id = "";
-      it->device.matched_output = MediaStreamDevice::AudioDeviceParameters();
-    }
-  }
-  CreateWebKitSourceVector(label, overridden_audio_array,
-                           blink::WebMediaStreamSource::TypeAudio,
-                           request_info->frame,
-                           audio_source_vector);
-
-  blink::WebVector<blink::WebMediaStreamSource> video_source_vector(
-      video_array.size());
-  CreateWebKitSourceVector(label, video_array,
-                           blink::WebMediaStreamSource::TypeVideo,
-                           request_info->frame,
-                           video_source_vector);
-  blink::WebUserMediaRequest* request = &(request_info->request);
-  blink::WebString webkit_id = base::UTF8ToUTF16(label);
-  blink::WebMediaStream* web_stream = &(request_info->web_stream);
-
-  blink::WebVector<blink::WebMediaStreamTrack> audio_track_vector(
-      audio_array.size());
-  for (size_t i = 0; i < audio_track_vector.size(); ++i) {
-    audio_track_vector[i].initialize(audio_source_vector[i]);
-    request_info->sources.push_back(audio_source_vector[i]);
-  }
-
-  blink::WebVector<blink::WebMediaStreamTrack> video_track_vector(
-      video_array.size());
-  for (size_t i = 0; i < video_track_vector.size(); ++i) {
-    video_track_vector[i].initialize(video_source_vector[i]);
-    request_info->sources.push_back(video_source_vector[i]);
-  }
-
-  web_stream->initialize(webkit_id, audio_track_vector,
-                         video_track_vector);
-
   // WebUserMediaRequest don't have an implementation in unit tests.
   // Therefore we need to check for isNull here.
+  blink::WebUserMediaRequest* request = &(request_info->request);
   blink::WebMediaConstraints audio_constraints = request->isNull() ?
       blink::WebMediaConstraints() : request->audioConstraints();
   blink::WebMediaConstraints video_constraints = request->isNull() ?
       blink::WebMediaConstraints() : request->videoConstraints();
 
-  dependency_factory_->CreateNativeMediaSources(
-      RenderViewObserver::routing_id(),
-      audio_constraints, video_constraints, web_stream,
-      base::Bind(&MediaStreamImpl::OnCreateNativeSourcesComplete, AsWeakPtr()));
+  blink::WebVector<blink::WebMediaStreamTrack> audio_track_vector(
+      audio_array.size());
+  CreateAudioTracks(audio_array, audio_constraints, &audio_track_vector,
+                    request_info);
+
+  blink::WebVector<blink::WebMediaStreamTrack> video_track_vector(
+      video_array.size());
+  CreateVideoTracks(video_array, video_constraints, &video_track_vector,
+                    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);
+
+  // 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) {
   DCHECK(CalledOnValidThread());
   DVLOG(1) << "MediaStreamImpl::OnStreamGenerationFailed("
            << request_id << ")";
   UserMediaRequestInfo* request_info = FindUserMediaRequestInfo(request_id);
   if (!request_info) {
@@ skipping 35 matching lines @@
       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()) {
-    RemoveSource(source, &(*it)->sources);
-    if ((*it)->sources.empty()) {
+    (*it)->RemoveSource(source);
+    if ((*it)->IsAllSourcesRemoved()) {
       it = user_media_requests_.erase(it);
     } else {
       ++it;
     }
   }
 }
 
-void MediaStreamImpl::CreateWebKitSourceVector(
-    const std::string& label,
+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);
+  if (existing_source) {
+    *webkit_source = *existing_source;
+    DVLOG(1) << "Source already exist. Reusing source with id "
+             << webkit_source->id().utf8();
+    return;
+  }
+
+  webkit_source->initialize(
+      base::UTF8ToUTF16(device.device.id),
+      type,
+      base::UTF8ToUTF16(device.device.name));
+
+  DVLOG(1) << "Initialize source object :"
+           << "id = " << webkit_source->id().utf8()
+           << ", name = " << webkit_source->name().utf8();
+
+  if (type == blink::WebMediaStreamSource::TypeVideo) {
+    MediaStreamVideoCapturerSource* video_source(
+        new content::MediaStreamVideoCapturerSource(
+            device,
+            base::Bind(&MediaStreamImpl::OnLocalSourceStopped, AsWeakPtr()),
+            dependency_factory_));
+    webkit_source->setExtraData(video_source);
+  } else {
+    DCHECK_EQ(blink::WebMediaStreamSource::TypeAudio, type);
+    MediaStreamAudioSource* audio_source(
+        new MediaStreamAudioSource(
+            device,
+            base::Bind(&MediaStreamImpl::OnLocalSourceStopped, AsWeakPtr())));
+    webkit_source->setExtraData(audio_source);
+    // TODO(xians): Move initialization from MediaStreamDependencyFactory
+    // to MediaStreamAudioSource.
+    dependency_factory_->InitializeMediaStreamAudioSource(
+        RenderViewObserver::routing_id(),
+        constraints,
+        *webkit_source);
+  }
+  local_sources_.push_back(LocalStreamSource(frame, *webkit_source));
+}
+
+void MediaStreamImpl::CreateVideoTracks(
     const StreamDeviceInfoArray& devices,
-    blink::WebMediaStreamSource::Type type,
-    blink::WebFrame* frame,
-    blink::WebVector<blink::WebMediaStreamSource>& webkit_sources) {
-  CHECK_EQ(devices.size(), webkit_sources.size());
+    const blink::WebMediaConstraints& constraints,
+    blink::WebVector<blink::WebMediaStreamTrack>* webkit_tracks,
+    UserMediaRequestInfo* request) {
+  DCHECK_EQ(devices.size(), webkit_tracks->size());
+
   for (size_t i = 0; i < devices.size(); ++i) {
-    const blink::WebMediaStreamSource* existing_source =
-        FindLocalSource(devices[i]);
-    if (existing_source) {
-      webkit_sources[i] = *existing_source;
-      DVLOG(1) << "Source already exist. Reusing source with id "
-               << webkit_sources[i]. id().utf8();
-      continue;
-    }
-    webkit_sources[i].initialize(
-        base::UTF8ToUTF16(devices[i].device.id),
-        type,
-        base::UTF8ToUTF16(devices[i].device.name));
-    MediaStreamSourceExtraData* source_extra_data(
-        new content::MediaStreamSourceExtraData(
-            devices[i],
-            base::Bind(&MediaStreamImpl::OnLocalSourceStop, AsWeakPtr())));
-    // |source_extra_data| is owned by webkit_sources[i].
-    webkit_sources[i].setExtraData(source_extra_data);
-    local_sources_.push_back(LocalStreamSource(frame, webkit_sources[i]));
+    blink::WebMediaStreamSource webkit_source;
+    InitializeSourceObject(devices[i],
+                           blink::WebMediaStreamSource::TypeVideo,
+                           constraints,
+                           request->frame,
+                           &webkit_source);
+    (*webkit_tracks)[i].initialize(webkit_source);
+    request->StartTrack((*webkit_tracks)[i], constraints);
   }
 }
 
-// Callback from MediaStreamDependencyFactory when the sources in |web_stream|
-// have been generated.
-void MediaStreamImpl::OnCreateNativeSourcesComplete(
-    blink::WebMediaStream* web_stream,
-    bool request_succeeded) {
-  UserMediaRequestInfo* request_info = FindUserMediaRequestInfo(web_stream);
-  if (!request_info) {
-    // This can happen if the request is canceled or the frame reloads while
-    // MediaStreamDependencyFactory is creating the sources.
-    DVLOG(1) << "Request ID not found";
-    return;
+void MediaStreamImpl::CreateAudioTracks(
+    const StreamDeviceInfoArray& devices,
+    const blink::WebMediaConstraints& constraints,
+    blink::WebVector<blink::WebMediaStreamTrack>* webkit_tracks,
+    UserMediaRequestInfo* request) {
+  DCHECK_EQ(devices.size(), webkit_tracks->size());
+
+  // Log the device names for this request.
+  for (StreamDeviceInfoArray::const_iterator it = devices.begin();
+       it != devices.end(); ++it) {
+    WebRtcLogMessage(base::StringPrintf(
+        "Generated media stream for request id %d contains audio device name"
+        " \"%s\"",
+        request->request_id,
+        it->device.name.c_str()));
   }
 
+  StreamDeviceInfoArray overridden_audio_array = devices;
+  if (!request->enable_automatic_output_device_selection) {
+    // If the GetUserMedia request did not explicitly set the constraint
+    // kMediaStreamRenderToAssociatedSink, the output device parameters must
+    // be removed.
+    for (StreamDeviceInfoArray::iterator it = overridden_audio_array.begin();
+        it != overridden_audio_array.end(); ++it) {
+      it->device.matched_output_device_id = "";
+      it->device.matched_output = MediaStreamDevice::AudioDeviceParameters();
+    }
+  }
+
+  for (size_t i = 0; i < overridden_audio_array.size(); ++i) {
+    blink::WebMediaStreamSource webkit_source;
+    InitializeSourceObject(overridden_audio_array[i],
+                           blink::WebMediaStreamSource::TypeAudio,
+                           constraints,
+                           request->frame,
+                           &webkit_source);
+    (*webkit_tracks)[i].initialize(webkit_source);
+    request->StartTrack((*webkit_tracks)[i], constraints);
+  }
+}
+
+void MediaStreamImpl::OnCreateNativeTracksCompleted(
+    UserMediaRequestInfo* request,
+    bool request_succeeded) {
   // Create a native representation of the stream.
   if (request_succeeded) {
     dependency_factory_->CreateNativeLocalMediaStream(
-        web_stream,
+        &request->web_stream,
         base::Bind(&MediaStreamImpl::OnLocalMediaStreamStop, AsWeakPtr()));
   }
-  DVLOG(1) << "MediaStreamImpl::OnCreateNativeSourcesComplete("
-           << "{request_id = " << request_info->request_id << "} "
+  DVLOG(1) << "MediaStreamImpl::OnCreateNativeTracksComplete("
+           << "{request_id = " << request->request_id << "} "
            << "{request_succeeded = " << request_succeeded << "})";
-  CompleteGetUserMediaRequest(request_info->web_stream, &request_info->request,
+  CompleteGetUserMediaRequest(request->web_stream, &request->request,
                               request_succeeded);
   if (!request_succeeded) {
     // TODO(perkj): Once we don't support MediaStream::Stop the |request_info|
     // can be deleted even if the request succeeds.
-    DeleteUserMediaRequestInfo(request_info);
+    DeleteUserMediaRequestInfo(request);
     StopUnreferencedSources(true);
   }
 }
 
 void MediaStreamImpl::OnDevicesEnumerated(
     int request_id,
     const StreamDeviceInfoArray& device_array) {
   DVLOG(1) << "MediaStreamImpl::OnDevicesEnumerated("
            << request_id << ")";
   NOTIMPLEMENTED();
@@ skipping 22 matching lines @@
     request_info->requestSucceeded(stream);
   } else {
     request_info->requestFailed();
   }
 }
 
 const blink::WebMediaStreamSource* MediaStreamImpl::FindLocalSource(
     const StreamDeviceInfo& device) const {
   for (LocalStreamSources::const_iterator it = local_sources_.begin();
        it != local_sources_.end(); ++it) {
-    MediaStreamSourceExtraData* extra_data =
-        static_cast<MediaStreamSourceExtraData*>(
-            it->source.extraData());
-    const StreamDeviceInfo& active_device = extra_data->device_info();
+    MediaStreamSource* source =
+        static_cast<MediaStreamSource*>(it->source.extraData());
+    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::FindSourceInRequests(
+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) {
-    const std::vector<blink::WebMediaStreamSource>& sources =
-        (*req_it)->sources;
-    for (std::vector<blink::WebMediaStreamSource>::const_iterator source_it =
-             sources.begin();
-         source_it != sources.end(); ++source_it) {
-      if (source_it->id() == source.id()) {
-        return true;
-      }
-    }
+    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);
@@ skipping 15 matching lines @@
 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;
 }
 
-MediaStreamImpl::UserMediaRequestInfo*
-MediaStreamImpl::FindUserMediaRequestInfo(
-    blink::WebMediaStream* web_stream) {
-  UserMediaRequests::iterator it = user_media_requests_.begin();
-  for (; it != user_media_requests_.end(); ++it) {
-    if (&((*it)->web_stream) == web_stream)
-      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 43 matching lines @@
     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::OnLocalSourceStop(
+void MediaStreamImpl::OnLocalSourceStopped(
     const blink::WebMediaStreamSource& source) {
   DCHECK(CalledOnValidThread());
 
-  StopLocalSource(source, true);
-
   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()) {
-    RemoveSource(source, &(*it)->sources);
-    if ((*it)->sources.empty()) {
+    (*it)->RemoveSource(source);
+    if ((*it)->IsAllSourcesRemoved()) {
       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) {
-  MediaStreamSourceExtraData* extra_data =
-        static_cast<MediaStreamSourceExtraData*> (source.extraData());
-  CHECK(extra_data);
+  MediaStreamSource* source_impl =
+      static_cast<MediaStreamSource*> (source.extraData());
   DVLOG(1) << "MediaStreamImpl::StopLocalSource("
-           << "{device_id = " << extra_data->device_info().device.id << "})";
-
-  if (source.type() == blink::WebMediaStreamSource::TypeAudio) {
-    if (extra_data->GetAudioCapturer())
-      extra_data->GetAudioCapturer()->Stop();
-  }
+           << "{device_id = " << source_impl->device_info().device.id << "})";
 
   if (notify_dispatcher)
-    media_stream_dispatcher_->StopStreamDevice(extra_data->device_info());
+    media_stream_dispatcher_->StopStreamDevice(source_impl->device_info());
 
-  blink::WebMediaStreamSource writable_source(source);
-  writable_source.setReadyState(
-      blink::WebMediaStreamSource::ReadyStateEnded);
-  writable_source.setExtraData(NULL);
+  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 (!FindSourceInRequests(source_it->source)) {
+    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) {
@@ skipping 44 matching lines @@
   DCHECK(CalledOnValidThread());
   WebRtcAudioDeviceImpl* audio_device =
       dependency_factory_->GetWebRtcAudioDevice();
   if (!audio_device)
     return false;
 
   return audio_device->GetAuthorizedDeviceInfoForAudioRenderer(
       session_id, output_sample_rate, output_frames_per_buffer);
 }
 
-MediaStreamSourceExtraData::MediaStreamSourceExtraData(
-    const StreamDeviceInfo& device_info,
-    const SourceStopCallback& stop_callback)
-    : device_info_(device_info),
-      stop_callback_(stop_callback) {
-}
-
-MediaStreamSourceExtraData::MediaStreamSourceExtraData() {
-}
-
-MediaStreamSourceExtraData::~MediaStreamSourceExtraData() {}
-
-void MediaStreamSourceExtraData::OnLocalSourceStop() {
-  if (!stop_callback_.is_null())
-    stop_callback_.Run(owner());
-}
-
 MediaStreamExtraData::MediaStreamExtraData(
     webrtc::MediaStreamInterface* stream, bool is_local)
     : stream_(stream),
       is_local_(is_local) {
 }
 
 MediaStreamExtraData::~MediaStreamExtraData() {
 }
 
 void MediaStreamExtraData::SetLocalStreamStopCallback(
     const StreamStopCallback& stop_callback) {
   stream_stop_callback_ = stop_callback;
 }
 
 void MediaStreamExtraData::OnLocalStreamStop() {
   if (!stream_stop_callback_.is_null())
     stream_stop_callback_.Run(stream_->label());
 }
 
 MediaStreamImpl::UserMediaRequestInfo::UserMediaRequestInfo(
     int request_id,
     blink::WebFrame* frame,
     const blink::WebUserMediaRequest& request,
     bool enable_automatic_output_device_selection)
     : request_id(request_id),
       generated(false),
       enable_automatic_output_device_selection(
           enable_automatic_output_device_selection),
       frame(frame),
-      request(request) {
+      request(request),
+      request_failed_(false) {
 }
 
 MediaStreamImpl::UserMediaRequestInfo::~UserMediaRequestInfo() {
+  DVLOG(1) << "~UserMediaRequestInfo";
+}
+
+void MediaStreamImpl::UserMediaRequestInfo::StartTrack(
+    const blink::WebMediaStreamTrack& track,
+    const blink::WebMediaConstraints& constraints) {
+  MediaStreamSource* native_source =
+      static_cast <MediaStreamSource*>(track.source().extraData());
+  DCHECK(native_source);
+
+  sources_.push_back(track.source());
+  sources_waiting_for_callback_.push_back(native_source);
+  native_source->AddTrack(
+      track, constraints, base::Bind(
+          &MediaStreamImpl::UserMediaRequestInfo::OnTrackStarted,
+          AsWeakPtr()));
+}
+
+void MediaStreamImpl::UserMediaRequestInfo::CallbackOnTracksStarted(
+    const ResourcesReady& callback) {
+  DCHECK(ready_callback_.is_null());
+  ready_callback_ = callback;
+  CheckAllTracksStarted();
+}
+
+void MediaStreamImpl::UserMediaRequestInfo::OnTrackStarted(
+    MediaStreamSource* source, bool success) {
+  DVLOG(1) << "OnTrackStarted";
+  std::vector<MediaStreamSource*>::iterator it =
+      std::find(sources_waiting_for_callback_.begin(),
+                sources_waiting_for_callback_.end(),
+                source);
+  DCHECK(it != sources_waiting_for_callback_.end());
+  sources_waiting_for_callback_.erase(it);
+  // All tracks must be started successfully. Otherwise the request is a
+  // failure.
+  if (!success)
+    request_failed_ = true;
+  CheckAllTracksStarted();
+}
+
+void MediaStreamImpl::UserMediaRequestInfo::CheckAllTracksStarted() {
+  if (!ready_callback_.is_null() && sources_waiting_for_callback_.empty())
+    ready_callback_.Run(this, !request_failed_);
+}
+
+bool MediaStreamImpl::UserMediaRequestInfo::IsSourceUsed(
+    const blink::WebMediaStreamSource& source) const {
+  for (std::vector<blink::WebMediaStreamSource>::const_iterator source_it =
+           sources_.begin();
+       source_it != sources_.end(); ++source_it) {
+    if (source_it->id() == source.id())
+      return true;
+  }
+  return false;
+}
+
+void MediaStreamImpl::UserMediaRequestInfo::RemoveSource(
+    const blink::WebMediaStreamSource& source) {
+  for (std::vector<blink::WebMediaStreamSource>::iterator it =
+           sources_.begin();
+       it != sources_.end(); ++it) {
+    if (source.id() == it->id()) {
+      sources_.erase(it);
+      return;
+    }
+  }
 }
 
 }  // namespace content