Renamed MediaStreamDependencyFactory to PeerConnectionDependencyFactory.

content/renderer/media/media_stream_impl_unittest.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 "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/child/child_process.h"
 #include "content/renderer/media/media_stream.h"
 #include "content/renderer/media/media_stream_impl.h"
 #include "content/renderer/media/media_stream_track.h"
-#include "content/renderer/media/mock_media_stream_dependency_factory.h"
 #include "content/renderer/media/mock_media_stream_dispatcher.h"
 #include "content/renderer/media/mock_media_stream_video_source.h"
+#include "content/renderer/media/webrtc/mock_peer_connection_dependency_factory.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebMediaStream.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 
 namespace content {
 
 class MockMediaStreamVideoCapturerSource : public MockMediaStreamVideoSource {
  public:
   MockMediaStreamVideoCapturerSource(
       const StreamDeviceInfo& device,
       const SourceStoppedCallback& stop_callback,
-      MediaStreamDependencyFactory* factory)
+      PeerConnectionDependencyFactory* factory)
   : MockMediaStreamVideoSource(false) {
     SetDeviceInfo(device);
     SetStopCallback(stop_callback);
   }
 };
 
 class MediaStreamImplUnderTest : public MediaStreamImpl {
  public:
   enum RequestState {
     REQUEST_NOT_STARTED,
     REQUEST_NOT_COMPLETE,
     REQUEST_SUCCEEDED,
     REQUEST_FAILED,
   };
 
   MediaStreamImplUnderTest(MediaStreamDispatcher* media_stream_dispatcher,
-                           MediaStreamDependencyFactory* dependency_factory)
+                           PeerConnectionDependencyFactory* dependency_factory)
       : MediaStreamImpl(NULL, media_stream_dispatcher, dependency_factory),
         state_(REQUEST_NOT_STARTED),
         result_(NUM_MEDIA_REQUEST_RESULTS),
         factory_(dependency_factory),
         video_source_(NULL) {
   }
 
   void RequestUserMedia() {
     blink::WebUserMediaRequest user_media_request;
     state_ = REQUEST_NOT_COMPLETE;
@@ skipping 36 matching lines @@
     return video_source_;
   }
 
   RequestState request_state() const { return state_; }
   content::MediaStreamRequestResult error_reason() const { return result_; }
 
  private:
   blink::WebMediaStream last_generated_stream_;
   RequestState state_;
   content::MediaStreamRequestResult result_;
-  MediaStreamDependencyFactory* factory_;
+  PeerConnectionDependencyFactory* factory_;
   MockMediaStreamVideoCapturerSource* video_source_;
 };
 
 class MediaStreamImplTest : public ::testing::Test {
  public:
   virtual void SetUp() {
     // Create our test object.
     child_process_.reset(new ChildProcess());
     ms_dispatcher_.reset(new MockMediaStreamDispatcher());
-    dependency_factory_.reset(new MockMediaStreamDependencyFactory());
+    dependency_factory_.reset(new MockPeerConnectionDependencyFactory());
     ms_impl_.reset(new MediaStreamImplUnderTest(ms_dispatcher_.get(),
                                                 dependency_factory_.get()));
   }
 
   blink::WebMediaStream RequestLocalMediaStream() {
     ms_impl_->RequestUserMedia();
     FakeMediaStreamDispatcherComplete();
     StartMockedVideoSource();
 
     EXPECT_EQ(MediaStreamImplUnderTest::REQUEST_SUCCEEDED,
@@ skipping 41 matching lines @@
 
   void FailToCreateNextAudioCapturer() {
     dependency_factory_->FailToCreateNextAudioCapturer();
   }
 
  protected:
   base::MessageLoop message_loop_;
   scoped_ptr<ChildProcess> child_process_;
   scoped_ptr<MockMediaStreamDispatcher> ms_dispatcher_;
   scoped_ptr<MediaStreamImplUnderTest> ms_impl_;
-  scoped_ptr<MockMediaStreamDependencyFactory> dependency_factory_;
+  scoped_ptr<MockPeerConnectionDependencyFactory> dependency_factory_;
 };
 
 TEST_F(MediaStreamImplTest, GenerateMediaStream) {
   // Generate a stream with both audio and video.
   blink::WebMediaStream mixed_desc = RequestLocalMediaStream();
 }
 
 // Test that the same source object is used if two MediaStreams are generated
 // using the same source.
 TEST_F(MediaStreamImplTest, GenerateTwoMediaStreamsWithSameSource) {
@@ skipping 209 matching lines @@
   EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter());
 
   blink::WebVector<blink::WebMediaStreamTrack> video_tracks;
   mixed_desc.videoTracks(video_tracks);
   MediaStreamTrack* video_track = MediaStreamTrack::GetTrack(video_tracks[0]);
   video_track->Stop();
   EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter());
 }
 
 }  // namespace content