Renamed WebMediaStreamComponent and WebMediaStreamDescriptor to WebMediaStreamTrack & WebMediaStream

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/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.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_dependency_factory.h"
 #include "content/renderer/media/media_stream_dispatcher.h"
 #include "content/renderer/media/rtc_video_decoder.h"
 #include "content/renderer/media/rtc_video_renderer.h"
 #include "content/renderer/media/video_capture_impl_manager.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_uma_histograms.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebMediaConstraints.h"
-#include "third_party/WebKit/Source/Platform/chromium/public/WebMediaStreamComponent.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebMediaStreamSource.h"
+#include "third_party/WebKit/Source/Platform/chromium/public/WebMediaStreamTrack.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebVector.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebMediaStreamRegistry.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityOrigin.h"
 #include "webkit/media/media_stream_audio_renderer.h"
 
 namespace content {
 namespace {
 
@@ skipping 50 matching lines @@
     webkit_sources[i].initialize(
           UTF8ToUTF16(source_id),
           type,
           UTF8ToUTF16(devices[i].device.name));
     webkit_sources[i].setExtraData(
         new content::MediaStreamSourceExtraData(devices[i]));
   }
 }
 
 webrtc::MediaStreamInterface* GetNativeMediaStream(
-    const WebKit::WebMediaStreamDescriptor& descriptor) {
+    const WebKit::WebMediaStream& descriptor) {
   content::MediaStreamExtraData* extra_data =
       static_cast<content::MediaStreamExtraData*>(descriptor.extraData());
   if (!extra_data)
     return NULL;
   webrtc::MediaStreamInterface* stream = extra_data->local_stream();
   if (!stream)
     stream = extra_data->remote_stream();
   return stream;
 }
 
@@ skipping 85 matching lines @@
   DCHECK(CalledOnValidThread());
   UserMediaRequestInfo* request = FindUserMediaRequestInfo(user_media_request);
   if (request) {
     // We can't abort the stream generation process.
     // Instead, erase the request. Once the stream is generated we will stop the
     // stream if the request does not exist.
     DeleteUserMediaRequestInfo(request);
   }
 }
 
-WebKit::WebMediaStreamDescriptor MediaStreamImpl::GetMediaStream(
+WebKit::WebMediaStream MediaStreamImpl::GetMediaStream(
     const GURL& url) {
   return WebKit::WebMediaStreamRegistry::lookupMediaStreamDescriptor(url);
 }
 
 bool MediaStreamImpl::IsMediaStream(const GURL& url) {
   return CheckMediaStream(url);
 }
 
 // static
 bool MediaStreamImpl::CheckMediaStream(const GURL& url) {
-  WebKit::WebMediaStreamDescriptor descriptor(
+  WebKit::WebMediaStream descriptor(
       WebKit::WebMediaStreamRegistry::lookupMediaStreamDescriptor(url));
 
   if (descriptor.isNull() || !descriptor.extraData())
     return false;  // This is not a valid stream.
 
   webrtc::MediaStreamInterface* stream = GetNativeMediaStream(descriptor);
   return stream &&
          ((stream->video_tracks() && stream->video_tracks()->count() > 0) ||
           (stream->audio_tracks() && stream->audio_tracks()->count() > 0));
 }
 
 scoped_refptr<webkit_media::VideoFrameProvider>
 MediaStreamImpl::GetVideoFrameProvider(
     const GURL& url,
     const base::Closure& error_cb,
     const webkit_media::VideoFrameProvider::RepaintCB& repaint_cb) {
   DCHECK(CalledOnValidThread());
-  WebKit::WebMediaStreamDescriptor descriptor(GetMediaStream(url));
+  WebKit::WebMediaStream descriptor(GetMediaStream(url));
 
   if (descriptor.isNull() || !descriptor.extraData())
     return NULL;  // This is not a valid stream.
 
   DVLOG(1) << "MediaStreamImpl::GetVideoFrameProvider stream:"
            << UTF16ToUTF8(descriptor.label());
 
   webrtc::MediaStreamInterface* stream = GetNativeMediaStream(descriptor);
   if (stream)
     return CreateVideoFrameProvider(stream, error_cb, repaint_cb);
   NOTREACHED();
   return NULL;
 }
 
 scoped_refptr<media::VideoDecoder> MediaStreamImpl::GetVideoDecoder(
     const GURL& url,
     const scoped_refptr<base::MessageLoopProxy>& message_loop) {
   DCHECK(CalledOnValidThread());
-  WebKit::WebMediaStreamDescriptor descriptor(GetMediaStream(url));
+  WebKit::WebMediaStream descriptor(GetMediaStream(url));
 
   if (descriptor.isNull() || !descriptor.extraData())
     return NULL;  // This is not a valid stream.
 
   DVLOG(1) << "MediaStreamImpl::GetVideoDecoder stream:"
            << UTF16ToUTF8(descriptor.label());
 
   webrtc::MediaStreamInterface* stream = GetNativeMediaStream(descriptor);
   if (stream)
     return CreateVideoDecoder(stream, message_loop);
   NOTREACHED();
   return NULL;
 }
 
 scoped_refptr<webkit_media::MediaStreamAudioRenderer>
 MediaStreamImpl::GetAudioRenderer(const GURL& url) {
   DCHECK(CalledOnValidThread());
-  WebKit::WebMediaStreamDescriptor descriptor(GetMediaStream(url));
+  WebKit::WebMediaStream descriptor(GetMediaStream(url));
 
   if (descriptor.isNull() || !descriptor.extraData())
     return NULL;  // This is not a valid stream.
 
   DVLOG(1) << "MediaStreamImpl::GetAudioRenderer stream:"
            << UTF16ToUTF8(descriptor.label());
 
   MediaStreamExtraData* extra_data =
       static_cast<MediaStreamExtraData*>(descriptor.extraData());
 
@@ skipping 47 matching lines @@
                            WebKit::WebMediaStreamSource::TypeAudio,
                            audio_source_vector);
   WebKit::WebVector<WebKit::WebMediaStreamSource> video_source_vector(
       video_array.size());
   CreateWebKitSourceVector(label, video_array,
                            WebKit::WebMediaStreamSource::TypeVideo,
                            video_source_vector);
 
   WebKit::WebUserMediaRequest* request = &(request_info->request);
   WebKit::WebString webkit_label = UTF8ToUTF16(label);
-  WebKit::WebMediaStreamDescriptor* description = &(request_info->descriptor);
+  WebKit::WebMediaStream* description = &(request_info->descriptor);
 
   description->initialize(webkit_label, audio_source_vector,
                           video_source_vector);
 
   // WebUserMediaRequest don't have an implementation in unit tests.
   // Therefore we need to check for isNull here.
   WebKit::WebMediaConstraints audio_constraints = request->isNull() ?
       WebKit::WebMediaConstraints() : request->audioConstraints();
   WebKit::WebMediaConstraints video_constraints = request->isNull() ?
       WebKit::WebMediaConstraints() : request->videoConstraints();
@@ skipping 18 matching lines @@
   }
   CompleteGetUserMediaRequest(request_info->descriptor,
                               &request_info->request,
                               false);
   DeleteUserMediaRequestInfo(request_info);
 }
 
 // Callback from MediaStreamDependencyFactory when the sources in |description|
 // have been generated.
 void MediaStreamImpl::OnCreateNativeSourcesComplete(
-    WebKit::WebMediaStreamDescriptor* description,
+    WebKit::WebMediaStream* description,
     bool request_succeeded) {
   DVLOG(1) << "MediaStreamImpl::OnCreateNativeSourcesComplete stream:"
            << UTF16ToUTF8(description->label());
   UserMediaRequestInfo* request_info = FindUserMediaRequestInfo(description);
   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;
   }
@@ skipping 34 matching lines @@
   NOTIMPLEMENTED();
 }
 
 void MediaStreamImpl::OnDeviceOpenFailed(int request_id) {
   DVLOG(1) << "MediaStreamImpl::VideoDeviceOpenFailed("
            << request_id << ")";
   NOTIMPLEMENTED();
 }
 
 void MediaStreamImpl::CompleteGetUserMediaRequest(
-    const WebKit::WebMediaStreamDescriptor& stream,
+    const WebKit::WebMediaStream& stream,
     WebKit::WebUserMediaRequest* request_info,
     bool request_succeeded) {
   if (request_succeeded) {
     request_info->requestSucceeded(stream);
   } else {
     request_info->requestFailed();
   }
 }
 
 MediaStreamImpl::UserMediaRequestInfo*
@@ skipping 22 matching lines @@
   UserMediaRequests::iterator it = user_media_requests_.begin();
   for (; it != user_media_requests_.end(); ++it) {
     if ((*it)->generated && (*it)->descriptor.label() == UTF8ToUTF16(label))
       return (*it);
   }
   return NULL;
 }
 
 MediaStreamImpl::UserMediaRequestInfo*
 MediaStreamImpl::FindUserMediaRequestInfo(
-    WebKit::WebMediaStreamDescriptor* descriptor) {
+    WebKit::WebMediaStream* descriptor) {
   UserMediaRequests::iterator it = user_media_requests_.begin();
   for (; it != user_media_requests_.end(); ++it) {
     if (&((*it)->descriptor) == descriptor)
       return  (*it);
   }
   return NULL;
 }
 
 void MediaStreamImpl::DeleteUserMediaRequestInfo(
     UserMediaRequestInfo* request) {
@@ skipping 126 matching lines @@
     const StreamStopCallback& stop_callback) {
   stream_stop_callback_ = stop_callback;
 }
 
 void MediaStreamExtraData::OnLocalStreamStop() {
   if (!stream_stop_callback_.is_null())
     stream_stop_callback_.Run(local_stream_->label());
 }
 
 }  // namespace content