Removed use of deprecated PeerConnection types and methods.

Removed use of MediaStreamTrackLists, LocalAudioTrackInterface, LocalVideoTrackInterface.
Deprecate the use of LocalMediaStreamInterface. Instead use MediaStreamInterface.

TEST= Make sure https://apprtc.appspot.com/?debug=loopback give you remote audio and video and local video.


Review URL: https://chromiumcodereview.appspot.com/12297027

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@183515 0039d316-1c4b-4281-b951-d872f2087c98

14 files changed, 126 insertions, 203 deletions

diff --git a/content/renderer/media/media_stream_center.cc b/content/renderer/media/media_stream_center.cc
index 145d340..29f2363 100644
--- a/content/renderer/media/media_stream_center.cc
+++ b/content/renderer/media/media_stream_center.cc
@@ -29,47 +29,24 @@ static webrtc::MediaStreamInterface* GetNativeMediaStream(
     const WebKit::WebMediaStream& stream) {
   MediaStreamExtraData* extra_data =
       static_cast<MediaStreamExtraData*>(stream.extraData());
-  if (extra_data && extra_data->remote_stream())
-    return extra_data->remote_stream();
-
-  if (extra_data && extra_data->local_stream())
-    return extra_data->local_stream();
-
-  // TODO(perkj): This can occur if a JS create a new MediaStream based on an
-  // existing MediaStream.
-  NOTIMPLEMENTED();
-  return NULL;
+  return extra_data->stream();
 }
 
-template <class TrackList>
-static webrtc::MediaStreamTrackInterface* GetTrack(
-    const std::string& source_id,
-    TrackList* tracks) {
-  for (size_t i = 0; i < tracks->count(); ++i) {
-    if (tracks->at(i)->id() == source_id)
-      return tracks->at(i);
-  }
-  return NULL;
-}
 
 static webrtc::MediaStreamTrackInterface* GetNativeMediaStreamTrack(
       const WebKit::WebMediaStream& stream,
       const WebKit::WebMediaStreamTrack& component) {
-  std::string source_id = UTF16ToUTF8(component.source().id());
+  std::string track_id = UTF16ToUTF8(component.id());
   webrtc::MediaStreamInterface* native_stream = GetNativeMediaStream(stream);
   if (native_stream) {
     if (component.source().type() == WebKit::WebMediaStreamSource::TypeAudio) {
-      return GetTrack<webrtc::AudioTracks>(
-          source_id, native_stream->audio_tracks());
+      return native_stream->FindAudioTrack(track_id);
     }
     if (component.source().type() == WebKit::WebMediaStreamSource::TypeVideo) {
-      return GetTrack<webrtc::VideoTracks>(
-          source_id, native_stream->video_tracks());
+      return native_stream->FindVideoTrack(track_id);
     }
   }
-  // TODO(perkj): This can occur if a JS create a new MediaStream based on an
-  // existing MediaStream.
-  NOTIMPLEMENTED();
+  NOTREACHED();
   return NULL;
 }
 
diff --git a/content/renderer/media/media_stream_dependency_factory.cc b/content/renderer/media/media_stream_dependency_factory.cc
index 9638d4a..a421369 100644
--- a/content/renderer/media/media_stream_dependency_factory.cc
+++ b/content/renderer/media/media_stream_dependency_factory.cc
@@ -304,7 +304,7 @@ void MediaStreamDependencyFactory::CreateNativeLocalMediaStream(
   }
 
   std::string label = UTF16ToUTF8(description->label());
-  scoped_refptr<webrtc::LocalMediaStreamInterface> native_stream =
+  scoped_refptr<webrtc::MediaStreamInterface> native_stream =
       CreateLocalMediaStream(label);
 
   // Add audio tracks.
@@ -337,7 +337,7 @@ void MediaStreamDependencyFactory::CreateNativeLocalMediaStream(
       continue;
     }
 
-    scoped_refptr<webrtc::LocalAudioTrackInterface> audio_track(
+    scoped_refptr<webrtc::AudioTrackInterface> audio_track(
         CreateLocalAudioTrack(UTF16ToUTF8(audio_tracks[i].id()),
                               source_data->local_audio_source()));
     native_stream->AddTrack(audio_track);
@@ -365,7 +365,8 @@ void MediaStreamDependencyFactory::CreateNativeLocalMediaStream(
     video_track->set_enabled(video_tracks[i].isEnabled());
   }
 
-  MediaStreamExtraData* extra_data = new MediaStreamExtraData(native_stream);
+  MediaStreamExtraData* extra_data = new MediaStreamExtraData(native_stream,
+                                                              true);
   description->setExtraData(extra_data);
 }
 
@@ -418,7 +419,7 @@ MediaStreamDependencyFactory::CreatePeerConnection(
       ice_servers, constraints, pa_factory, observer).get();
 }
 
-scoped_refptr<webrtc::LocalMediaStreamInterface>
+scoped_refptr<webrtc::MediaStreamInterface>
 MediaStreamDependencyFactory::CreateLocalMediaStream(
     const std::string& label) {
   return pc_factory_->CreateLocalMediaStream(label).get();
@@ -515,7 +516,7 @@ MediaStreamDependencyFactory::CreateLocalVideoTrack(
   return pc_factory_->CreateVideoTrack(id, source).get();
 }
 
-scoped_refptr<webrtc::LocalAudioTrackInterface>
+scoped_refptr<webrtc::AudioTrackInterface>
 MediaStreamDependencyFactory::CreateLocalAudioTrack(
     const std::string& id,
     webrtc::AudioSourceInterface* source) {
diff --git a/content/renderer/media/media_stream_dependency_factory.h b/content/renderer/media/media_stream_dependency_factory.h
index fe75792..9183263 100644
--- a/content/renderer/media/media_stream_dependency_factory.h
+++ b/content/renderer/media/media_stream_dependency_factory.h
@@ -116,7 +116,7 @@ class CONTENT_EXPORT MediaStreamDependencyFactory
 
  protected:
   // Asks the PeerConnection factory to create a Local MediaStream object.
-  virtual scoped_refptr<webrtc::LocalMediaStreamInterface>
+  virtual scoped_refptr<webrtc::MediaStreamInterface>
       CreateLocalMediaStream(const std::string& label);
 
   // Asks the PeerConnection factory to create a Local Audio Source.
@@ -143,7 +143,7 @@ class CONTENT_EXPORT MediaStreamDependencyFactory
   virtual bool CreateWebAudioSource(WebKit::WebMediaStreamSource* source);
 
   // Asks the PeerConnection factory to create a Local AudioTrack object.
-  virtual scoped_refptr<webrtc::LocalAudioTrackInterface>
+  virtual scoped_refptr<webrtc::AudioTrackInterface>
       CreateLocalAudioTrack(const std::string& id,
                             webrtc::AudioSourceInterface* source);
 
diff --git a/content/renderer/media/media_stream_dependency_factory_unittest.cc b/content/renderer/media/media_stream_dependency_factory_unittest.cc
index 638f83f..a44f134 100644
--- a/content/renderer/media/media_stream_dependency_factory_unittest.cc
+++ b/content/renderer/media/media_stream_dependency_factory_unittest.cc
@@ -127,9 +127,10 @@ TEST_F(MediaStreamDependencyFactoryTest, CreateNativeMediaStream) {
 
   content::MediaStreamExtraData* extra_data =
       static_cast<content::MediaStreamExtraData*>(stream_desc.extraData());
-  ASSERT_TRUE(extra_data && extra_data->local_stream());
-  EXPECT_EQ(1u, extra_data->local_stream()->audio_tracks()->count());
-  EXPECT_EQ(1u, extra_data->local_stream()->video_tracks()->count());
+  ASSERT_TRUE(extra_data && extra_data->stream());
+  EXPECT_TRUE(extra_data->is_local());
+  EXPECT_EQ(1u, extra_data->stream()->GetAudioTracks().size());
+  EXPECT_EQ(1u, extra_data->stream()->GetVideoTracks().size());
 }
 
 // Test that we don't crash if a MediaStream is created in WebKit with unknown
@@ -154,9 +155,10 @@ TEST_F(MediaStreamDependencyFactoryTest, CreateNativeMediaStreamWithoutSource) {
   dependency_factory_->CreateNativeLocalMediaStream(&stream_desc);
   MediaStreamExtraData* extra_data = static_cast<MediaStreamExtraData*>(
       stream_desc.extraData());
-  ASSERT_TRUE(extra_data && extra_data->local_stream());
-  EXPECT_EQ(0u, extra_data->local_stream()->video_tracks()->count());
-  EXPECT_EQ(0u, extra_data->local_stream()->audio_tracks()->count());
+  ASSERT_TRUE(extra_data && extra_data->stream());
+  EXPECT_TRUE(extra_data->is_local());
+  EXPECT_EQ(0u, extra_data->stream()->GetVideoTracks().size());
+  EXPECT_EQ(0u, extra_data->stream()->GetAudioTracks().size());
 }
 
 }  // namespace content
diff --git a/content/renderer/media/media_stream_extra_data.h b/content/renderer/media/media_stream_extra_data.h
index d9ef62c..5ddc45c 100644
--- a/content/renderer/media/media_stream_extra_data.h
+++ b/content/renderer/media/media_stream_extra_data.h
@@ -13,7 +13,6 @@
 
 namespace webrtc {
 class MediaStreamInterface;
-class LocalMediaStreamInterface;
 }  // namespace webrtc
 
 namespace content {
@@ -23,24 +22,22 @@ class CONTENT_EXPORT MediaStreamExtraData
  public:
   typedef base::Callback<void(const std::string& label)> StreamStopCallback;
 
-  explicit MediaStreamExtraData(webrtc::MediaStreamInterface* remote_stream);
-  explicit MediaStreamExtraData(
-      webrtc::LocalMediaStreamInterface* local_stream);
+  MediaStreamExtraData(webrtc::MediaStreamInterface* stream, bool is_local);
   virtual ~MediaStreamExtraData();
 
+  bool is_local() const { return is_local_; }
+
   void SetLocalStreamStopCallback(
       const StreamStopCallback& stop_callback);
   void OnLocalStreamStop();
 
-  webrtc::MediaStreamInterface* remote_stream() { return remote_stream_.get(); }
-  webrtc::LocalMediaStreamInterface* local_stream() {
-    return local_stream_.get();
+  const scoped_refptr<webrtc::MediaStreamInterface>& stream() const {
+    return stream_;
   }
-
  private:
   StreamStopCallback stream_stop_callback_;
-  scoped_refptr<webrtc::MediaStreamInterface> remote_stream_;
-  scoped_refptr<webrtc::LocalMediaStreamInterface> local_stream_;
+  scoped_refptr<webrtc::MediaStreamInterface> stream_;
+  bool is_local_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaStreamExtraData);
 };
diff --git a/content/renderer/media/media_stream_impl.cc b/content/renderer/media/media_stream_impl.cc
index eed5f3b..5a1627d 100644
--- a/content/renderer/media/media_stream_impl.cc
+++ b/content/renderer/media/media_stream_impl.cc
@@ -103,10 +103,7 @@ webrtc::MediaStreamInterface* GetNativeMediaStream(
       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;
+  return extra_data->stream();
 }
 
 }  // namespace
@@ -222,9 +219,8 @@ bool MediaStreamImpl::CheckMediaStream(const GURL& url) {
     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));
+  return (stream &&
+      (!stream->GetVideoTracks().empty() || !stream->GetAudioTracks().empty()));
 }
 
 scoped_refptr<webkit_media::VideoFrameProvider>
@@ -281,27 +277,24 @@ MediaStreamImpl::GetAudioRenderer(const GURL& url) {
   MediaStreamExtraData* extra_data =
       static_cast<MediaStreamExtraData*>(descriptor.extraData());
 
-  if (extra_data->remote_stream()) {
-    WebRtcAudioDeviceImpl* audio_device =
-        dependency_factory_->GetWebRtcAudioDevice();
+  if (extra_data->is_local()) {
+    // Create the local audio renderer if the stream contains audio tracks.
+    return CreateLocalAudioRenderer(extra_data->stream());
+  }
 
-    // Share the existing renderer if any, otherwise create a new one.
-    scoped_refptr<WebRtcAudioRenderer> renderer(audio_device->renderer());
-    if (!renderer) {
-      renderer = CreateRemoteAudioRenderer(extra_data->remote_stream());
+  // This is a remote media stream.
+  WebRtcAudioDeviceImpl* audio_device =
+      dependency_factory_->GetWebRtcAudioDevice();
 
-      if (renderer && !audio_device->SetRenderer(renderer))
-        renderer = NULL;
-    }
+  // Share the existing renderer if any, otherwise create a new one.
+  scoped_refptr<WebRtcAudioRenderer> renderer(audio_device->renderer());
+  if (!renderer) {
+    renderer = CreateRemoteAudioRenderer(extra_data->stream());
 
-    return renderer;
-  } else if (extra_data->local_stream()) {
-    // Create the local audio renderer if the stream contains audio tracks.
-    return CreateLocalAudioRenderer(extra_data->local_stream());
+    if (renderer && !audio_device->SetRenderer(renderer))
+      renderer = NULL;
   }
-
-  NOTREACHED();
-  return NULL;
+  return renderer;
 }
 
 // Callback from MediaStreamDispatcher.
@@ -528,14 +521,14 @@ MediaStreamImpl::CreateVideoFrameProvider(
     webrtc::MediaStreamInterface* stream,
     const base::Closure& error_cb,
     const webkit_media::VideoFrameProvider::RepaintCB& repaint_cb) {
-  if (!stream->video_tracks() || stream->video_tracks()->count() == 0)
+  if (stream->GetVideoTracks().empty())
     return NULL;
 
   DVLOG(1) << "MediaStreamImpl::CreateRemoteVideoFrameProvider label:"
            << stream->label();
 
   return new RTCVideoRenderer(
-      stream->video_tracks()->at(0),
+      stream->GetVideoTracks()[0],
       error_cb,
       repaint_cb);
 }
@@ -543,21 +536,22 @@ MediaStreamImpl::CreateVideoFrameProvider(
 scoped_refptr<media::VideoDecoder> MediaStreamImpl::CreateVideoDecoder(
     webrtc::MediaStreamInterface* stream,
     const scoped_refptr<base::MessageLoopProxy>& message_loop) {
-  if (!stream->video_tracks() || stream->video_tracks()->count() == 0)
+  if (stream->GetVideoTracks().empty())
     return NULL;
 
+
   DVLOG(1) << "MediaStreamImpl::CreateRemoteVideoDecoder label:"
            << stream->label();
 
   return new RTCVideoDecoder(
       message_loop,
       base::MessageLoopProxy::current(),
-      stream->video_tracks()->at(0));
+      stream->GetVideoTracks()[0].get());
 }
 
 scoped_refptr<WebRtcAudioRenderer> MediaStreamImpl::CreateRemoteAudioRenderer(
     webrtc::MediaStreamInterface* stream) {
-  if (!stream->audio_tracks() || stream->audio_tracks()->count() == 0)
+  if (stream->GetAudioTracks().empty())
     return NULL;
 
   DVLOG(1) << "MediaStreamImpl::CreateRemoteAudioRenderer label:"
@@ -569,7 +563,7 @@ scoped_refptr<WebRtcAudioRenderer> MediaStreamImpl::CreateRemoteAudioRenderer(
 scoped_refptr<WebRtcLocalAudioRenderer>
 MediaStreamImpl::CreateLocalAudioRenderer(
     webrtc::MediaStreamInterface* stream) {
-  if (!stream->audio_tracks() || stream->audio_tracks()->count() == 0)
+  if (stream->GetAudioTracks().empty())
     return NULL;
 
   DVLOG(1) << "MediaStreamImpl::CreateLocalAudioRenderer label:"
@@ -599,13 +593,9 @@ MediaStreamSourceExtraData::MediaStreamSourceExtraData(
 MediaStreamSourceExtraData::~MediaStreamSourceExtraData() {}
 
 MediaStreamExtraData::MediaStreamExtraData(
-    webrtc::MediaStreamInterface* remote_stream)
-    : remote_stream_(remote_stream) {
-}
-
-MediaStreamExtraData::MediaStreamExtraData(
-    webrtc::LocalMediaStreamInterface* local_stream)
-    : local_stream_(local_stream) {
+    webrtc::MediaStreamInterface* stream, bool is_local)
+    : stream_(stream),
+      is_local_(is_local) {
 }
 
 MediaStreamExtraData::~MediaStreamExtraData() {
@@ -618,7 +608,7 @@ void MediaStreamExtraData::SetLocalStreamStopCallback(
 
 void MediaStreamExtraData::OnLocalStreamStop() {
   if (!stream_stop_callback_.is_null())
-    stream_stop_callback_.Run(local_stream_->label());
+    stream_stop_callback_.Run(stream_->label());
 }
 
 }  // namespace content
diff --git a/content/renderer/media/media_stream_impl_unittest.cc b/content/renderer/media/media_stream_impl_unittest.cc
index c56f930..5fe8650 100644
--- a/content/renderer/media/media_stream_impl_unittest.cc
+++ b/content/renderer/media/media_stream_impl_unittest.cc
@@ -102,18 +102,18 @@ class MediaStreamImplTest : public ::testing::Test {
     WebKit::WebMediaStream desc = ms_impl_->last_generated_stream();
     content::MediaStreamExtraData* extra_data =
         static_cast<content::MediaStreamExtraData*>(desc.extraData());
-    if (!extra_data || !extra_data->local_stream()) {
+    if (!extra_data || !extra_data->stream()) {
       ADD_FAILURE();
       return desc;
     }
 
     if (audio)
-      EXPECT_EQ(1u, extra_data->local_stream()->audio_tracks()->count());
+      EXPECT_EQ(1u, extra_data->stream()->GetAudioTracks().size());
     if (video)
-      EXPECT_EQ(1u, extra_data->local_stream()->video_tracks()->count());
+      EXPECT_EQ(1u, extra_data->stream()->GetVideoTracks().size());
     if (audio && video) {
-      EXPECT_NE(extra_data->local_stream()->audio_tracks()->at(0)->id(),
-                extra_data->local_stream()->video_tracks()->at(0)->id());
+      EXPECT_NE(extra_data->stream()->GetAudioTracks()[0]->id(),
+                extra_data->stream()->GetVideoTracks()[0]->id());
     }
     return desc;
   }
diff --git a/content/renderer/media/mock_media_stream_dependency_factory.cc b/content/renderer/media/mock_media_stream_dependency_factory.cc
index 5b7c35b..79fb8c5 100644
--- a/content/renderer/media/mock_media_stream_dependency_factory.cc
+++ b/content/renderer/media/mock_media_stream_dependency_factory.cc
@@ -14,7 +14,7 @@ using webrtc::AudioTrackInterface;
 using webrtc::AudioTrackVector;
 using webrtc::IceCandidateCollection;
 using webrtc::IceCandidateInterface;
-using webrtc::LocalMediaStreamInterface;
+using webrtc::MediaStreamInterface;
 using webrtc::ObserverInterface;
 using webrtc::SessionDescriptionInterface;
 using webrtc::VideoRendererInterface;
@@ -24,54 +24,29 @@ using webrtc::VideoTrackVector;
 
 namespace content {
 
-template <class TrackType>
-class MockMediaStreamTrackList
-    : public webrtc::MediaStreamTrackListInterface<TrackType> {
- public:
-  virtual size_t count() const OVERRIDE {
-    return tracks_.size();
-  }
-
-  virtual TrackType* at(size_t index) OVERRIDE {
-    return tracks_[index];
-  }
-
-  virtual TrackType* Find(const std::string& id) OVERRIDE {
-    for (size_t i = 0; i < tracks_.size(); ++i) {
-      if (tracks_.at(i)->id() == id) {
-        return tracks_.at(i);
-      }
+template <class V>
+static typename V::iterator FindTrack(V* vector,
+                                      const std::string& track_id) {
+  typename V::iterator it = vector->begin();
+  for (; it != vector->end(); ++it) {
+    if ((*it)->id() == track_id) {
+      break;
     }
-    return NULL;
   }
-
-  void AddTrack(TrackType* track) {
-    tracks_.push_back(track);
-  }
-
- protected:
-  virtual ~MockMediaStreamTrackList() {}
-
- private:
-  std::vector<scoped_refptr<TrackType> > tracks_;
+  return it;
 };
 
-typedef MockMediaStreamTrackList<AudioTrackInterface> MockAudioTracks;
-typedef MockMediaStreamTrackList<VideoTrackInterface> MockVideoTracks;
-
-class MockLocalMediaStream : public webrtc::LocalMediaStreamInterface {
+class MockMediaStream : public webrtc::MediaStreamInterface {
  public:
-  explicit MockLocalMediaStream(std::string label)
-    : label_(label),
-      audio_tracks_(new talk_base::RefCountedObject<MockAudioTracks>),
-      video_tracks_(new talk_base::RefCountedObject<MockVideoTracks>) {
+  explicit MockMediaStream(const std::string& label)
+      : label_(label) {
   }
   virtual bool AddTrack(AudioTrackInterface* track) OVERRIDE {
-    audio_tracks_->AddTrack(track);
+    audio_track_vector_.push_back(track);
     return true;
   }
   virtual bool AddTrack(VideoTrackInterface* track) OVERRIDE {
-    video_tracks_->AddTrack(track);
+    video_track_vector_.push_back(track);
     return true;
   }
   virtual bool RemoveTrack(AudioTrackInterface* track) OVERRIDE {
@@ -91,19 +66,21 @@ class MockLocalMediaStream : public webrtc::LocalMediaStreamInterface {
   }
   virtual talk_base::scoped_refptr<AudioTrackInterface>
       FindAudioTrack(const std::string& track_id) OVERRIDE {
-    NOTIMPLEMENTED();
-    return NULL;
+    AudioTrackVector::iterator it = FindTrack(&audio_track_vector_, track_id);
+    return it == audio_track_vector_.end() ? NULL : *it;
   }
   virtual talk_base::scoped_refptr<VideoTrackInterface>
       FindVideoTrack(const std::string& track_id) OVERRIDE {
-    NOTIMPLEMENTED();
-    return NULL;
+    VideoTrackVector::iterator it = FindTrack(&video_track_vector_, track_id);
+    return it == video_track_vector_.end() ? NULL : *it;
   }
   virtual webrtc::AudioTracks* audio_tracks() OVERRIDE {
-    return audio_tracks_;
+    NOTIMPLEMENTED();
+    return NULL;
   }
   virtual webrtc::VideoTracks* video_tracks() OVERRIDE {
-    return video_tracks_;
+    NOTIMPLEMENTED();
+    return NULL;
   }
   virtual void RegisterObserver(ObserverInterface* observer) OVERRIDE {
     NOTIMPLEMENTED();
@@ -113,12 +90,10 @@ class MockLocalMediaStream : public webrtc::LocalMediaStreamInterface {
   }
 
  protected:
-  virtual ~MockLocalMediaStream() {}
+  virtual ~MockMediaStream() {}
 
  private:
   std::string label_;
-  scoped_refptr<MockAudioTracks> audio_tracks_;
-  scoped_refptr<MockVideoTracks> video_tracks_;
   AudioTrackVector audio_track_vector_;
   VideoTrackVector video_track_vector_;
 };
@@ -410,7 +385,7 @@ bool MockMediaStreamDependencyFactory::PeerConnectionFactoryCreated() {
 
 scoped_refptr<webrtc::PeerConnectionInterface>
 MockMediaStreamDependencyFactory::CreatePeerConnection(
-    const webrtc::JsepInterface::IceServers& ice_servers,
+    const webrtc::PeerConnectionInterface::IceServers& ice_servers,
     const webrtc::MediaConstraintsInterface* constraints,
     WebKit::WebFrame* frame,
     webrtc::PeerConnectionObserver* observer) {
@@ -445,11 +420,11 @@ bool MockMediaStreamDependencyFactory::CreateWebAudioSource(
   return true;
 }
 
-scoped_refptr<webrtc::LocalMediaStreamInterface>
+scoped_refptr<webrtc::MediaStreamInterface>
 MockMediaStreamDependencyFactory::CreateLocalMediaStream(
     const std::string& label) {
   DCHECK(mock_pc_factory_created_);
-  return new talk_base::RefCountedObject<MockLocalMediaStream>(label);
+  return new talk_base::RefCountedObject<MockMediaStream>(label);
 }
 
 scoped_refptr<webrtc::VideoTrackInterface>
@@ -463,12 +438,12 @@ MockMediaStreamDependencyFactory::CreateLocalVideoTrack(
   return track;
 }
 
-scoped_refptr<webrtc::LocalAudioTrackInterface>
+scoped_refptr<webrtc::AudioTrackInterface>
 MockMediaStreamDependencyFactory::CreateLocalAudioTrack(
     const std::string& id,
     webrtc::AudioSourceInterface* source) {
   DCHECK(mock_pc_factory_created_);
-  scoped_refptr<webrtc::LocalAudioTrackInterface> track(
+  scoped_refptr<webrtc::AudioTrackInterface> track(
       new talk_base::RefCountedObject<MockLocalAudioTrack>(id));
   return track;
 }
diff --git a/content/renderer/media/mock_media_stream_dependency_factory.h b/content/renderer/media/mock_media_stream_dependency_factory.h
index 2e5c585..e7c4221 100644
--- a/content/renderer/media/mock_media_stream_dependency_factory.h
+++ b/content/renderer/media/mock_media_stream_dependency_factory.h
@@ -128,11 +128,11 @@ class MockMediaStreamDependencyFactory : public MediaStreamDependencyFactory {
   MockMediaStreamDependencyFactory();
   virtual ~MockMediaStreamDependencyFactory();
 
-  virtual scoped_refptr<webrtc::PeerConnectionInterface>
-      CreatePeerConnection(const webrtc::JsepInterface::IceServers& ice_servers,
-                           const webrtc::MediaConstraintsInterface* constraints,
-                           WebKit::WebFrame* frame,
-                           webrtc::PeerConnectionObserver* observer) OVERRIDE;
+  virtual scoped_refptr<webrtc::PeerConnectionInterface> CreatePeerConnection(
+      const webrtc::PeerConnectionInterface::IceServers& ice_servers,
+      const webrtc::MediaConstraintsInterface* constraints,
+      WebKit::WebFrame* frame,
+      webrtc::PeerConnectionObserver* observer) OVERRIDE;
   virtual scoped_refptr<webrtc::AudioSourceInterface>
       CreateLocalAudioSource(
           const webrtc::MediaConstraintsInterface* constraints) OVERRIDE;
@@ -145,12 +145,12 @@ class MockMediaStreamDependencyFactory : public MediaStreamDependencyFactory {
       const StreamDeviceInfo& device_info) OVERRIDE;
   virtual bool CreateWebAudioSource(
       WebKit::WebMediaStreamSource* source) OVERRIDE;
-  virtual scoped_refptr<webrtc::LocalMediaStreamInterface>
+  virtual scoped_refptr<webrtc::MediaStreamInterface>
       CreateLocalMediaStream(const std::string& label) OVERRIDE;
   virtual scoped_refptr<webrtc::VideoTrackInterface>
       CreateLocalVideoTrack(const std::string& id,
                             webrtc::VideoSourceInterface* source) OVERRIDE;
-  virtual scoped_refptr<webrtc::LocalAudioTrackInterface>
+  virtual scoped_refptr<webrtc::AudioTrackInterface>
       CreateLocalAudioTrack(const std::string& id,
                             webrtc::AudioSourceInterface* source) OVERRIDE;
   virtual webrtc::SessionDescriptionInterface* CreateSessionDescription(
diff --git a/content/renderer/media/mock_peer_connection_impl.cc b/content/renderer/media/mock_peer_connection_impl.cc
index c72889d..9e779c8 100644
--- a/content/renderer/media/mock_peer_connection_impl.cc
+++ b/content/renderer/media/mock_peer_connection_impl.cc
@@ -14,7 +14,6 @@ using webrtc::CreateSessionDescriptionObserver;
 using webrtc::DtmfSenderInterface;
 using webrtc::DtmfSenderObserverInterface;
 using webrtc::IceCandidateInterface;
-using webrtc::LocalMediaStreamInterface;
 using webrtc::MediaConstraintsInterface;
 using webrtc::MediaStreamInterface;
 using webrtc::PeerConnectionInterface;
@@ -42,7 +41,7 @@ class MockStreamCollection : public webrtc::StreamCollectionInterface {
       const std::string& id) OVERRIDE {
     for (size_t i = 0; i < streams_.size(); ++i) {
       webrtc::MediaStreamTrackInterface* track =
-          streams_.at(i)->audio_tracks()->Find(id);
+          streams_.at(i)->FindAudioTrack(id);
       if (track)
         return track;
     }
@@ -52,7 +51,7 @@ class MockStreamCollection : public webrtc::StreamCollectionInterface {
       const std::string& id) OVERRIDE {
     for (size_t i = 0; i < streams_.size(); ++i) {
       webrtc::MediaStreamTrackInterface* track =
-          streams_.at(i)->video_tracks()->Find(id);
+          streams_.at(i)->FindVideoTrack(id);
       if (track)
         return track;
     }
diff --git a/content/renderer/media/peer_connection_handler_base.cc b/content/renderer/media/peer_connection_handler_base.cc
index 12b91cd..76ba132 100644
--- a/content/renderer/media/peer_connection_handler_base.cc
+++ b/content/renderer/media/peer_connection_handler_base.cc
@@ -16,23 +16,12 @@
 namespace content {
 
 // TODO(hta): Unify implementations of these functions from MediaStreamCenter
-static webrtc::LocalMediaStreamInterface* GetLocalNativeMediaStream(
+static webrtc::MediaStreamInterface* GetNativeMediaStream(
     const WebKit::WebMediaStream& stream) {
   MediaStreamExtraData* extra_data =
       static_cast<MediaStreamExtraData*>(stream.extraData());
   if (extra_data)
-    return extra_data->local_stream();
-  return NULL;
-}
-
-template <class TrackList>
-static webrtc::MediaStreamTrackInterface* GetLocalTrack(
-    const std::string& track_id,
-    TrackList* tracks) {
-  for (size_t i = 0; i < tracks->count(); ++i) {
-    if (tracks->at(i)->id() == track_id)
-      return tracks->at(i);
-  }
+    return extra_data->stream();
   return NULL;
 }
 
@@ -48,8 +37,7 @@ PeerConnectionHandlerBase::~PeerConnectionHandlerBase() {
 bool PeerConnectionHandlerBase::AddStream(
     const WebKit::WebMediaStream& stream,
     const webrtc::MediaConstraintsInterface* constraints) {
-  webrtc::LocalMediaStreamInterface* native_stream =
-      GetLocalNativeMediaStream(stream);
+  webrtc::MediaStreamInterface* native_stream = GetNativeMediaStream(stream);
   if (!native_stream)
     return false;
   return native_peer_connection_->AddStream(native_stream, constraints);
@@ -57,27 +45,26 @@ bool PeerConnectionHandlerBase::AddStream(
 
 void PeerConnectionHandlerBase::RemoveStream(
     const WebKit::WebMediaStream& stream) {
-  webrtc::LocalMediaStreamInterface* native_stream =
-      GetLocalNativeMediaStream(stream);
+  webrtc::MediaStreamInterface* native_stream = GetNativeMediaStream(stream);
   if (native_stream)
     native_peer_connection_->RemoveStream(native_stream);
   DCHECK(native_stream);
 }
 
 WebKit::WebMediaStream
-PeerConnectionHandlerBase::CreateWebKitStreamDescriptor(
+PeerConnectionHandlerBase::CreateRemoteWebKitMediaStream(
     webrtc::MediaStreamInterface* stream) {
-  webrtc::AudioTracks* audio_tracks = stream->audio_tracks();
-  webrtc::VideoTracks* video_tracks = stream->video_tracks();
+  webrtc::AudioTrackVector audio_tracks = stream->GetAudioTracks();
+  webrtc::VideoTrackVector video_tracks = stream->GetVideoTracks();
   WebKit::WebVector<WebKit::WebMediaStreamSource> audio_source_vector(
-      audio_tracks->count());
+      audio_tracks.size());
   WebKit::WebVector<WebKit::WebMediaStreamSource> video_source_vector(
-      video_tracks->count());
+      video_tracks.size());
 
   // Add audio tracks.
   size_t i = 0;
-  for (; i < audio_tracks->count(); ++i) {
-    webrtc::AudioTrackInterface* audio_track = audio_tracks->at(i);
+  for (; i < audio_tracks.size(); ++i) {
+    webrtc::AudioTrackInterface* audio_track = audio_tracks[i];
     DCHECK(audio_track);
     audio_source_vector[i].initialize(
         UTF8ToUTF16(audio_track->id()),
@@ -86,8 +73,8 @@ PeerConnectionHandlerBase::CreateWebKitStreamDescriptor(
   }
 
   // Add video tracks.
-  for (i = 0; i < video_tracks->count(); ++i) {
-    webrtc::VideoTrackInterface* video_track = video_tracks->at(i);
+  for (i = 0; i < video_tracks.size(); ++i) {
+    webrtc::VideoTrackInterface* video_track = video_tracks[i];
     DCHECK(video_track);
     video_source_vector[i].initialize(
         UTF8ToUTF16(video_track->id()),
@@ -97,7 +84,7 @@ PeerConnectionHandlerBase::CreateWebKitStreamDescriptor(
   WebKit::WebMediaStream descriptor;
   descriptor.initialize(UTF8ToUTF16(stream->label()),
                         audio_source_vector, video_source_vector);
-  descriptor.setExtraData(new MediaStreamExtraData(stream));
+  descriptor.setExtraData(new MediaStreamExtraData(stream, false));
   return descriptor;
 }
 
@@ -106,18 +93,15 @@ PeerConnectionHandlerBase::GetLocalNativeMediaStreamTrack(
       const WebKit::WebMediaStream& stream,
       const WebKit::WebMediaStreamTrack& track) {
   std::string track_id = UTF16ToUTF8(track.id());
-  webrtc::MediaStreamInterface* native_stream
-      = GetLocalNativeMediaStream(stream);
+  webrtc::MediaStreamInterface* native_stream = GetNativeMediaStream(stream);
   if (!native_stream) {
     return NULL;
   }
   if (track.source().type() == WebKit::WebMediaStreamSource::TypeAudio) {
-    return GetLocalTrack<webrtc::AudioTracks>(
-        track_id, native_stream->audio_tracks());
+    return native_stream->FindAudioTrack(track_id);
   }
   if (track.source().type() == WebKit::WebMediaStreamSource::TypeVideo) {
-    return GetLocalTrack<webrtc::VideoTracks>(
-        track_id, native_stream->video_tracks());
+    return native_stream->FindVideoTrack(track_id);
   }
   NOTIMPLEMENTED();  // We have an unknown type of media stream track.
   return NULL;
diff --git a/content/renderer/media/peer_connection_handler_base.h b/content/renderer/media/peer_connection_handler_base.h
index d84bbb3..215454b 100644
--- a/content/renderer/media/peer_connection_handler_base.h
+++ b/content/renderer/media/peer_connection_handler_base.h
@@ -35,7 +35,7 @@ class CONTENT_EXPORT PeerConnectionHandlerBase
   bool AddStream(const WebKit::WebMediaStream& stream,
                  const webrtc::MediaConstraintsInterface* constraints);
   void RemoveStream(const WebKit::WebMediaStream& stream);
-  WebKit::WebMediaStream CreateWebKitStreamDescriptor(
+  WebKit::WebMediaStream CreateRemoteWebKitMediaStream(
       webrtc::MediaStreamInterface* stream);
   webrtc::MediaStreamTrackInterface* GetLocalNativeMediaStreamTrack(
       const WebKit::WebMediaStream& stream,
diff --git a/content/renderer/media/rtc_peer_connection_handler.cc b/content/renderer/media/rtc_peer_connection_handler.cc
index 0841139..b45db50 100644
--- a/content/renderer/media/rtc_peer_connection_handler.cc
+++ b/content/renderer/media/rtc_peer_connection_handler.cc
@@ -683,7 +683,7 @@ void RTCPeerConnectionHandler::OnAddStream(
   DCHECK(stream_interface);
   DCHECK(remote_streams_.find(stream_interface) == remote_streams_.end());
   WebKit::WebMediaStream stream =
-      CreateWebKitStreamDescriptor(stream_interface);
+      CreateRemoteWebKitMediaStream(stream_interface);
 
   if (peer_connection_tracker_)
     peer_connection_tracker_->TrackAddStream(
diff --git a/content/renderer/media/rtc_peer_connection_handler_unittest.cc b/content/renderer/media/rtc_peer_connection_handler_unittest.cc
index 749a5d5..73a12df 100644
--- a/content/renderer/media/rtc_peer_connection_handler_unittest.cc
+++ b/content/renderer/media/rtc_peer_connection_handler_unittest.cc
@@ -228,24 +228,24 @@ class RTCPeerConnectionHandlerTest : public ::testing::Test {
     local_stream.initialize(UTF8ToUTF16(stream_label), audio_sources,
                             video_sources);
 
-    scoped_refptr<webrtc::LocalMediaStreamInterface> native_stream(
+    scoped_refptr<webrtc::MediaStreamInterface> native_stream(
         mock_dependency_factory_->CreateLocalMediaStream(stream_label));
     WebKit::WebVector<WebKit::WebMediaStreamTrack> audio_tracks;
     local_stream.audioSources(audio_tracks);
     const std::string audio_track_id = UTF16ToUTF8(audio_tracks[0].id());
-    scoped_refptr<webrtc::LocalAudioTrackInterface> audio_track(
+    scoped_refptr<webrtc::AudioTrackInterface> audio_track(
         mock_dependency_factory_->CreateLocalAudioTrack(audio_track_id,
                                                         NULL));
     native_stream->AddTrack(audio_track);
     WebKit::WebVector<WebKit::WebMediaStreamTrack> video_tracks;
     local_stream.audioSources(video_tracks);
     const std::string video_track_id = UTF16ToUTF8(video_tracks[0].id());
-    scoped_refptr<webrtc::LocalVideoTrackInterface> video_track(
+    scoped_refptr<webrtc::VideoTrackInterface> video_track(
         mock_dependency_factory_->CreateLocalVideoTrack(
             video_track_id, 0));
     native_stream->AddTrack(video_track);
 
-    local_stream.setExtraData(new MediaStreamExtraData(native_stream));
+    local_stream.setExtraData(new MediaStreamExtraData(native_stream, true));
     return local_stream;
   }
 
@@ -255,18 +255,16 @@ class RTCPeerConnectionHandlerTest : public ::testing::Test {
   AddRemoteMockMediaStream(const std::string& stream_label,
                            const std::string& video_track_label,
                            const std::string& audio_track_label) {
-    // We use a local stream as a remote since for testing purposes we really
-    // only need the MediaStreamInterface.
-    scoped_refptr<webrtc::LocalMediaStreamInterface> stream(
+    scoped_refptr<webrtc::MediaStreamInterface> stream(
         mock_dependency_factory_->CreateLocalMediaStream(stream_label));
     if (!video_track_label.empty()) {
-      scoped_refptr<webrtc::LocalVideoTrackInterface> video_track(
+      scoped_refptr<webrtc::VideoTrackInterface> video_track(
           mock_dependency_factory_->CreateLocalVideoTrack(
               video_track_label, 0));
       stream->AddTrack(video_track);
     }
     if (!audio_track_label.empty()) {
-      scoped_refptr<webrtc::LocalAudioTrackInterface> audio_track(
+      scoped_refptr<webrtc::AudioTrackInterface> audio_track(
           mock_dependency_factory_->CreateLocalAudioTrack(audio_track_label,
                                                           NULL));
       stream->AddTrack(audio_track);
@@ -383,9 +381,9 @@ TEST_F(RTCPeerConnectionHandlerTest, addAndRemoveStream) {
   EXPECT_TRUE(pc_handler_->addStream(local_stream, constraints));
   EXPECT_EQ(stream_label, mock_peer_connection_->stream_label());
   EXPECT_EQ(1u,
-      mock_peer_connection_->local_streams()->at(0)->audio_tracks()->count());
+      mock_peer_connection_->local_streams()->at(0)->GetAudioTracks().size());
   EXPECT_EQ(1u,
-      mock_peer_connection_->local_streams()->at(0)->video_tracks()->count());
+      mock_peer_connection_->local_streams()->at(0)->GetVideoTracks().size());
 
   pc_handler_->removeStream(local_stream);
   EXPECT_EQ(0u, mock_peer_connection_->local_streams()->count());