Renamed WebMediaStreamComponent and WebMediaStreamDescriptor to WebMediaStreamTrack & WebMediaStream

content/renderer/media/media_stream_dependency_factory.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_dependency_factory.h"
 
 #include <vector>
 
 #include "base/synchronization/waitable_event.h"
 #include "base/utf_string_conversions.h"
 #include "content/renderer/media/media_stream_source_extra_data.h"
 #include "content/renderer/media/rtc_media_constraints.h"
 #include "content/renderer/media/rtc_peer_connection_handler.h"
 #include "content/renderer/media/rtc_video_capturer.h"
 #include "content/renderer/media/video_capture_impl_manager.h"
 #include "content/renderer/media/webaudio_capturer_source.h"
 #include "content/renderer/media/webrtc_audio_device_impl.h"
 #include "content/renderer/media/webrtc_uma_histograms.h"
 #include "content/renderer/p2p/ipc_network_manager.h"
 #include "content/renderer/p2p/ipc_socket_factory.h"
 #include "content/renderer/p2p/port_allocator.h"
 #include "jingle/glue/thread_wrapper.h"
-#include "third_party/WebKit/Source/Platform/chromium/public/WebMediaStreamComponent.h"
-#include "third_party/WebKit/Source/Platform/chromium/public/WebMediaStreamDescriptor.h"
+#include "third_party/WebKit/Source/Platform/chromium/public/WebMediaStream.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/WebKit/chromium/public/WebFrame.h"
 
 #if !defined(USE_OPENSSL)
 #include "net/socket/nss_ssl_util.h"
 #endif
 
 namespace content {
 
 class P2PPortAllocatorFactory : public webrtc::PortAllocatorFactoryInterface {
  public:
@@ skipping 42 matching lines @@
   talk_base::NetworkManager* network_manager_;
   talk_base::PacketSocketFactory* socket_factory_;
   // Raw ptr to the WebFrame that created the P2PPortAllocatorFactory.
   WebKit::WebFrame* web_frame_;
 };
 
 // SourceStateObserver is a help class used for observing the startup state
 // transition of webrtc media sources such as a camera or microphone.
 // An instance of the object deletes itself after use.
 // Usage:
-// 1. Create an instance of the object with the WebKit::WebMediaStreamDescriptor
+// 1. Create an instance of the object with the WebKit::WebMediaStream
 //    the observed sources belongs to a callback.
 // 2. Add the sources to the observer using AddSource.
 // 3. Call StartObserving()
 // 4. The callback will be triggered when all sources have transitioned from
 //    webrtc::MediaSourceInterface::kInitializing.
 class SourceStateObserver : public webrtc::ObserverInterface,
                             public base::NonThreadSafe {
  public:
   SourceStateObserver(
-      WebKit::WebMediaStreamDescriptor* description,
+      WebKit::WebMediaStream* description,
       const MediaStreamDependencyFactory::MediaSourcesCreatedCallback& callback)
      : description_(description),
        ready_callback_(callback),
        live_(true) {
   }
 
   void AddSource(webrtc::MediaSourceInterface* source) {
     DCHECK(CalledOnValidThread());
     switch (source->state()) {
       case webrtc::MediaSourceInterface::kInitializing:
@@ skipping 33 matching lines @@
       } else {
         ++it;
       }
     }
     if (sources_.empty()) {
       ready_callback_.Run(description_, live_);
       delete this;
     }
   }
 
-  WebKit::WebMediaStreamDescriptor* description_;
+  WebKit::WebMediaStream* description_;
   MediaStreamDependencyFactory::MediaSourcesCreatedCallback ready_callback_;
   bool live_;
   typedef std::vector<scoped_refptr<webrtc::MediaSourceInterface> >
       ObservedSources;
   ObservedSources sources_;
 };
 
 MediaStreamDependencyFactory::MediaStreamDependencyFactory(
     VideoCaptureImplManager* vc_manager,
     P2PSocketDispatcher* p2p_socket_dispatcher)
@@ skipping 19 matching lines @@
 
   if (!EnsurePeerConnectionFactory())
     return NULL;
 
   return new RTCPeerConnectionHandler(client, this);
 }
 
 void MediaStreamDependencyFactory::CreateNativeMediaSources(
     const WebKit::WebMediaConstraints& audio_constraints,
     const WebKit::WebMediaConstraints& video_constraints,
-    WebKit::WebMediaStreamDescriptor* description,
+    WebKit::WebMediaStream* description,
     const MediaSourcesCreatedCallback& sources_created) {
   DVLOG(1) << "MediaStreamDependencyFactory::CreateNativeMediaSources()";
   if (!EnsurePeerConnectionFactory()) {
     sources_created.Run(description, false);
     return;
   }
 
   // |source_observer| clean up itself when it has completed
   // source_observer->StartObservering.
   SourceStateObserver* source_observer =
       new SourceStateObserver(description, sources_created);
 
   // Create local video sources.
   RTCMediaConstraints native_video_constraints(video_constraints);
-  WebKit::WebVector<WebKit::WebMediaStreamComponent> video_components;
+  WebKit::WebVector<WebKit::WebMediaStreamTrack> video_components;
   description->videoSources(video_components);
   for (size_t i = 0; i < video_components.size(); ++i) {
     const WebKit::WebMediaStreamSource& source = video_components[i].source();
     MediaStreamSourceExtraData* source_data =
         static_cast<MediaStreamSourceExtraData*>(source.extraData());
     if (!source_data) {
       // TODO(perkj): Implement support for sources from remote MediaStreams.
       NOTIMPLEMENTED();
       continue;
     }
     const bool is_screencast = (source_data->device_info().device.type ==
         content::MEDIA_TAB_VIDEO_CAPTURE);
     source_data->SetVideoSource(
         CreateLocalVideoSource(source_data->device_info().session_id,
                                is_screencast,
                                &native_video_constraints));
     source_observer->AddSource(source_data->video_source());
   }
 
   // Do additional source initialization if the audio source is a valid
   // microphone or tab audio.
   RTCMediaConstraints native_audio_constraints(audio_constraints);
-  WebKit::WebVector<WebKit::WebMediaStreamComponent> audio_components;
+  WebKit::WebVector<WebKit::WebMediaStreamTrack> audio_components;
   description->audioSources(audio_components);
   for (size_t i = 0; i < audio_components.size(); ++i) {
     const WebKit::WebMediaStreamSource& source = audio_components[i].source();
     MediaStreamSourceExtraData* source_data =
         static_cast<MediaStreamSourceExtraData*>(source.extraData());
     if (!source_data) {
       // TODO(henrika): Implement support for sources from remote MediaStreams.
       NOTIMPLEMENTED();
       continue;
     }
@@ skipping 10 matching lines @@
     // Creates a LocalAudioSource object which holds audio options.
     source_data->SetLocalAudioSource(
         CreateLocalAudioSource(&native_audio_constraints));
     source_observer->AddSource(source_data->local_audio_source());
   }
 
   source_observer->StartObservering();
 }
 
 void MediaStreamDependencyFactory::CreateNativeLocalMediaStream(
-    WebKit::WebMediaStreamDescriptor* description) {
+    WebKit::WebMediaStream* description) {
   DVLOG(1) << "MediaStreamDependencyFactory::CreateNativeLocalMediaStream()";
   if (!EnsurePeerConnectionFactory()) {
       DVLOG(1) << "EnsurePeerConnectionFactory() failed!";
       return;
   }
 
   std::string label = UTF16ToUTF8(description->label());
   scoped_refptr<webrtc::LocalMediaStreamInterface> native_stream =
       CreateLocalMediaStream(label);
 
   // Add audio tracks.
-  WebKit::WebVector<WebKit::WebMediaStreamComponent> audio_components;
+  WebKit::WebVector<WebKit::WebMediaStreamTrack> audio_components;
   description->audioSources(audio_components);
 
   for (size_t i = 0; i < audio_components.size(); ++i) {
     WebKit::WebMediaStreamSource source = audio_components[i].source();
 
     // See if we're adding a WebAudio MediaStream.
     if (source.requiresAudioConsumer()) {
       // TODO(crogers, xians): In reality we should be able to send a unique
       // audio stream to each PeerConnection separately.  But currently WebRTC
       // is only able to handle a global audio stream sent to ALL peers.
@@ skipping 22 matching lines @@
 
         scoped_refptr<webrtc::LocalAudioTrackInterface> audio_track(
             CreateLocalAudioTrack(UTF16ToUTF8(source.id()),
                                   source_data->local_audio_source()));
         native_stream->AddTrack(audio_track);
         audio_track->set_enabled(audio_components[i].isEnabled());
     }
   }
 
   // Add video tracks.
-  WebKit::WebVector<WebKit::WebMediaStreamComponent> video_components;
+  WebKit::WebVector<WebKit::WebMediaStreamTrack> video_components;
   description->videoSources(video_components);
   for (size_t i = 0; i < video_components.size(); ++i) {
     const WebKit::WebMediaStreamSource& source = video_components[i].source();
     MediaStreamSourceExtraData* source_data =
         static_cast<MediaStreamSourceExtraData*>(source.extraData());
     if (!source_data || !source_data->video_source()) {
       // TODO(perkj): Implement support for sources from remote MediaStreams.
       NOTIMPLEMENTED();
       continue;
     }
 
     scoped_refptr<webrtc::VideoTrackInterface> video_track(
         CreateLocalVideoTrack(UTF16ToUTF8(source.id()),
                               source_data->video_source()));
 
     native_stream->AddTrack(video_track);
     video_track->set_enabled(video_components[i].isEnabled());
   }
 
   MediaStreamExtraData* extra_data = new MediaStreamExtraData(native_stream);
   description->setExtraData(extra_data);
 }
 
 void MediaStreamDependencyFactory::CreateNativeLocalMediaStream(
-    WebKit::WebMediaStreamDescriptor* description,
+    WebKit::WebMediaStream* description,
     const MediaStreamExtraData::StreamStopCallback& stream_stop) {
   CreateNativeLocalMediaStream(description);
 
   MediaStreamExtraData* extra_data =
      static_cast<MediaStreamExtraData*>(description->extraData());
   extra_data->SetLocalStreamStopCallback(stream_stop);
 }
 
 bool MediaStreamDependencyFactory::CreatePeerConnectionFactory() {
   DVLOG(1) << "MediaStreamDependencyFactory::CreatePeerConnectionFactory()";
@@ skipping 234 matching lines @@
       // processed before returning. We wait for the above task to finish before
       // letting the the function continue to avoid any potential race issues.
       chrome_worker_thread_.Stop();
     } else {
       NOTREACHED() << "Worker thread not running.";
     }
   }
 }
 
 }  // namespace content