Chrome MediaStream VideoTrack implementation.

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 460 matching lines @@
     UserMediaRequestInfo* request) {
   DCHECK_EQ(devices.size(), webkit_tracks->size());
 
   for (size_t i = 0; i < devices.size(); ++i) {
     blink::WebMediaStreamSource webkit_source;
     InitializeSourceObject(devices[i],
                            blink::WebMediaStreamSource::TypeVideo,
                            constraints,
                            request->frame,
                            &webkit_source);
-    (*webkit_tracks)[i].initialize(webkit_source);
-    (*webkit_tracks)[i].setExtraData(new MediaStreamVideoTrack(
-        dependency_factory_));
-    request->StartTrack((*webkit_tracks)[i], constraints);
+    (*webkit_tracks)[i] =
+        request->CreateAndStartVideoTrack(webkit_source, constraints,
+                                          dependency_factory_);
   }
 }
 
 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());
 
@@ skipping 20 matching lines @@
   }
 
   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);
+    request->StartAudioTrack((*webkit_tracks)[i], constraints);
   }
 }
 
 void MediaStreamImpl::OnCreateNativeTracksCompleted(
     UserMediaRequestInfo* request,
     bool request_succeeded) {
   DVLOG(1) << "MediaStreamImpl::OnCreateNativeTracksComplete("
            << "{request_id = " << request->request_id << "} "
            << "{request_succeeded = " << request_succeeded << "})";
   CompleteGetUserMediaRequest(request->web_stream, &request->request,
@@ skipping 291 matching lines @@
           enable_automatic_output_device_selection),
       frame(frame),
       request(request),
       request_failed_(false) {
 }
 
 MediaStreamImpl::UserMediaRequestInfo::~UserMediaRequestInfo() {
   DVLOG(1) << "~UserMediaRequestInfo";
 }
 
-void MediaStreamImpl::UserMediaRequestInfo::StartTrack(
+void MediaStreamImpl::UserMediaRequestInfo::StartAudioTrack(
     const blink::WebMediaStreamTrack& track,
     const blink::WebMediaConstraints& constraints) {
-  MediaStreamSource* native_source =
-      static_cast <MediaStreamSource*>(track.source().extraData());
+  DCHECK(track.source().type() == blink::WebMediaStreamSource::TypeAudio);
+  MediaStreamAudioSource* native_source =
+      static_cast <MediaStreamAudioSource*>(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()));
 }
 
+blink::WebMediaStreamTrack
+MediaStreamImpl::UserMediaRequestInfo::CreateAndStartVideoTrack(
+    const blink::WebMediaStreamSource& source,
+    const blink::WebMediaConstraints& constraints,
+    MediaStreamDependencyFactory* factory) {
+  DCHECK(source.type() == blink::WebMediaStreamSource::TypeVideo);
+  MediaStreamVideoSource* native_source =
+      MediaStreamVideoSource::GetVideoSource(source);
+  DCHECK(native_source);
+  sources_.push_back(source);
+  sources_waiting_for_callback_.push_back(native_source);
+  return MediaStreamVideoTrack::CreateVideoTrack(
+      native_source, constraints, base::Bind(
+          &MediaStreamImpl::UserMediaRequestInfo::OnTrackStarted,
+          AsWeakPtr()),
+      true, factory);
+}
+
 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";
@@ skipping 32 matching lines @@
            sources_.begin();
        it != sources_.end(); ++it) {
     if (source.id() == it->id()) {
       sources_.erase(it);
       return;
     }
   }
 }
 
 }  // namespace content