Renamed MediaStreamDependencyFactory to PeerConnectionDependencyFactory.

content/renderer/media/media_stream_center.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_center.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "content/common/media/media_stream_messages.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/renderer/media_stream_audio_sink.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/renderer/media/media_stream.h"
-#include "content/renderer/media/media_stream_dependency_factory.h"
 #include "content/renderer/media/media_stream_source.h"
 #include "content/renderer/media/media_stream_video_source.h"
 #include "content/renderer/media/media_stream_video_track.h"
+#include "content/renderer/media/webrtc/peer_connection_dependency_factory.h"
 #include "content/renderer/media/webrtc_local_audio_source_provider.h"
 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
 #include "third_party/WebKit/public/platform/WebMediaStream.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamCenterClient.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrackSourcesRequest.h"
 #include "third_party/WebKit/public/platform/WebSourceInfo.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 
 using blink::WebFrame;
 using blink::WebView;
 
 namespace content {
 
 namespace {
 
 void CreateNativeAudioMediaStreamTrack(
     const blink::WebMediaStreamTrack& track,
-    MediaStreamDependencyFactory* factory) {
+    PeerConnectionDependencyFactory* factory) {
   DCHECK(!track.extraData());
   blink::WebMediaStreamSource source = track.source();
   DCHECK_EQ(source.type(), blink::WebMediaStreamSource::TypeAudio);
   factory->CreateLocalAudioTrack(track);
 }
 
 void CreateNativeVideoMediaStreamTrack(
     const blink::WebMediaStreamTrack& track) {
   DCHECK(track.extraData() == NULL);
   blink::WebMediaStreamSource source = track.source();
@@ skipping 10 matching lines @@
   blink::WebMediaConstraints constraints = source.constraints();
   if (constraints.isNull())
     constraints.initialize();
   writable_track.setExtraData(
       new MediaStreamVideoTrack(native_source, constraints,
                                 MediaStreamVideoSource::ConstraintsCallback(),
                                 track.isEnabled()));
 }
 
 void CreateNativeMediaStreamTrack(const blink::WebMediaStreamTrack& track,
-                                  MediaStreamDependencyFactory* factory) {
+                                  PeerConnectionDependencyFactory* factory) {
   DCHECK(!track.isNull() && !track.extraData());
   DCHECK(!track.source().isNull());
 
   switch (track.source().type()) {
     case blink::WebMediaStreamSource::TypeAudio:
       CreateNativeAudioMediaStreamTrack(track, factory);
       break;
     case blink::WebMediaStreamSource::TypeVideo:
       CreateNativeVideoMediaStreamTrack(track);
       break;
   }
 }
 
 }  // namespace
 
 MediaStreamCenter::MediaStreamCenter(blink::WebMediaStreamCenterClient* client,
-                                     MediaStreamDependencyFactory* factory)
+                                     PeerConnectionDependencyFactory* factory)
     : rtc_factory_(factory), next_request_id_(0) {}
 
 MediaStreamCenter::~MediaStreamCenter() {}
 
 bool MediaStreamCenter::getMediaStreamTrackSources(
     const blink::WebMediaStreamTrackSourcesRequest& request) {
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kDisableDeviceEnumeration)) {
     int request_id = next_request_id_++;
     requests_.insert(std::make_pair(request_id, request));
@@ skipping 35 matching lines @@
 }
 
 blink::WebAudioSourceProvider*
 MediaStreamCenter::createWebAudioSourceFromMediaStreamTrack(
     const blink::WebMediaStreamTrack& track) {
   DVLOG(1) << "MediaStreamCenter::createWebAudioSourceFromMediaStreamTrack";
   MediaStreamTrack* media_stream_track =
       static_cast<MediaStreamTrack*>(track.extraData());
   // Only local audio track is supported now.
   // TODO(xians): Support remote audio track.
-  if (!media_stream_track || !media_stream_track->is_local_track ()) {
+  if (!media_stream_track || !media_stream_track->is_local_track()) {
     NOTIMPLEMENTED();
     return NULL;
   }
 
   blink::WebMediaStreamSource source = track.source();
   DCHECK_EQ(source.type(), blink::WebMediaStreamSource::TypeAudio);
   WebRtcLocalAudioSourceProvider* source_provider =
       new WebRtcLocalAudioSourceProvider(track);
   return source_provider;
 }
@@ skipping 26 matching lines @@
   MediaStream* native_stream(
       new MediaStream(stream));
   writable_stream.setExtraData(native_stream);
 
   blink::WebVector<blink::WebMediaStreamTrack> video_tracks;
   stream.videoTracks(video_tracks);
   for (size_t i = 0; i < video_tracks.size(); ++i) {
     if (!MediaStreamTrack::GetTrack(video_tracks[i]))
       CreateNativeMediaStreamTrack(video_tracks[i], rtc_factory_);
   }
-
 }
 
 bool MediaStreamCenter::didAddMediaStreamTrack(
     const blink::WebMediaStream& stream,
     const blink::WebMediaStreamTrack& track) {
   DVLOG(1) << "MediaStreamCenter::didAddMediaStreamTrack";
   MediaStream* native_stream = MediaStream::GetMediaStream(stream);
   return native_stream->AddTrack(track);
 }
 
@@ skipping 43 matching lines @@
                     device.type == MEDIA_DEVICE_AUDIO_CAPTURE
                         ? blink::WebSourceInfo::SourceKindAudio
                         : blink::WebSourceInfo::SourceKindVideo,
                     blink::WebString::fromUTF8(device.name),
                     video_facing);
   }
   request_it->second.requestSucceeded(sourceInfos);
 }
 
 }  // namespace content