Renamed WebMediaStreamComponent and WebMediaStreamDescriptor to WebMediaStreamTrack & WebMediaStream

content/renderer/media/rtc_peer_connection_handler_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 <string>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/utf_string_conversions.h"
 #include "content/renderer/media/media_stream_extra_data.h"
 #include "content/renderer/media/mock_media_stream_dependency_factory.h"
 #include "content/renderer/media/mock_peer_connection_impl.h"
 #include "content/renderer/media/mock_web_rtc_peer_connection_handler_client.h"
 #include "content/renderer/media/rtc_peer_connection_handler.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "third_party/libjingle/source/talk/app/webrtc/peerconnectioninterface.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/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/Platform/chromium/public/WebRTCConfiguration.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebRTCDataChannelHandler.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebRTCICECandidate.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebRTCPeerConnectionHandlerClient.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebRTCSessionDescription.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebRTCSessionDescriptionRequest.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebRTCStatsRequest.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebRTCVoidRequest.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebURL.h"
+#include "third_party/libjingle/source/talk/app/webrtc/peerconnectioninterface.h"
 
 static const char kDummySdp[] = "dummy sdp";
 static const char kDummySdpType[] = "dummy type";
 
 namespace content {
 
 class MockRTCStatsResponse : public LocalRTCStatsResponse {
  public:
   MockRTCStatsResponse()
       : report_count_(0),
@@ skipping 28 matching lines @@
 class MockRTCStatsRequest : public LocalRTCStatsRequest {
  public:
   MockRTCStatsRequest()
       : has_selector_(false),
         stream_(),
         request_succeeded_called_(false) {}
 
   virtual bool hasSelector() const OVERRIDE {
     return has_selector_;
   }
-  virtual WebKit::WebMediaStreamDescriptor stream() const OVERRIDE {
+  virtual WebKit::WebMediaStream stream() const OVERRIDE {
     return stream_;
   }
-  virtual WebKit::WebMediaStreamComponent component() const OVERRIDE {
+  virtual WebKit::WebMediaStreamTrack component() const OVERRIDE {
     return component_;
   }
   virtual scoped_refptr<LocalRTCStatsResponse> createResponse() OVERRIDE {
     DCHECK(!response_);
     response_ = new talk_base::RefCountedObject<MockRTCStatsResponse>();
     return response_;
   }
 
   virtual void requestSucceeded(const LocalRTCStatsResponse* response)
       OVERRIDE {
     EXPECT_EQ(response, response_.get());
     request_succeeded_called_ = true;
   }
 
   // Function for setting whether or not a selector is available.
-  void setSelector(const WebKit::WebMediaStreamDescriptor& stream,
-                   const WebKit::WebMediaStreamComponent& component) {
+  void setSelector(const WebKit::WebMediaStream& stream,
+                   const WebKit::WebMediaStreamTrack& component) {
     has_selector_ = true;
     stream_ = stream;
     component_ = component;
   }
 
   // Function for inspecting the result of a stats request.
   MockRTCStatsResponse* result() {
     if (request_succeeded_called_) {
       return response_.get();
     } else {
       return NULL;
     }
   }
 
  private:
   bool has_selector_;
-  WebKit::WebMediaStreamDescriptor stream_;
-  WebKit::WebMediaStreamComponent component_;
+  WebKit::WebMediaStream stream_;
+  WebKit::WebMediaStreamTrack component_;
   scoped_refptr<MockRTCStatsResponse> response_;
   bool request_succeeded_called_;
 };
 
 class RTCPeerConnectionHandlerUnderTest : public RTCPeerConnectionHandler {
  public:
   RTCPeerConnectionHandlerUnderTest(
       WebKit::WebRTCPeerConnectionHandlerClient* client,
       MediaStreamDependencyFactory* dependency_factory)
       : RTCPeerConnectionHandler(client, dependency_factory) {
@@ skipping 19 matching lines @@
 
     WebKit::WebRTCConfiguration config;
     WebKit::WebMediaConstraints constraints;
     EXPECT_TRUE(pc_handler_->InitializeForTest(config, constraints));
 
     mock_peer_connection_ = pc_handler_->native_peer_connection();
     ASSERT_TRUE(mock_peer_connection_);
   }
 
   // Creates a WebKit local MediaStream.
-  WebKit::WebMediaStreamDescriptor CreateLocalMediaStream(
+  WebKit::WebMediaStream CreateLocalMediaStream(
       const std::string& stream_label) {
     std::string video_track_label("video-label");
     std::string audio_track_label("audio-label");
 
     scoped_refptr<webrtc::LocalMediaStreamInterface> native_stream(
         mock_dependency_factory_->CreateLocalMediaStream(stream_label));
     scoped_refptr<webrtc::LocalAudioTrackInterface> audio_track(
         mock_dependency_factory_->CreateLocalAudioTrack(audio_track_label,
                                                         NULL));
     native_stream->AddTrack(audio_track);
     scoped_refptr<webrtc::LocalVideoTrackInterface> video_track(
         mock_dependency_factory_->CreateLocalVideoTrack(
             video_track_label, 0));
     native_stream->AddTrack(video_track);
 
     WebKit::WebVector<WebKit::WebMediaStreamSource> audio_sources(
         static_cast<size_t>(1));
     audio_sources[0].initialize(WebKit::WebString::fromUTF8(audio_track_label),
                                 WebKit::WebMediaStreamSource::TypeAudio,
                                 WebKit::WebString::fromUTF8("audio_track"));
     WebKit::WebVector<WebKit::WebMediaStreamSource> video_sources(
         static_cast<size_t>(1));
     video_sources[0].initialize(WebKit::WebString::fromUTF8(video_track_label),
                                 WebKit::WebMediaStreamSource::TypeVideo,
                                 WebKit::WebString::fromUTF8("video_track"));
-    WebKit::WebMediaStreamDescriptor local_stream;
+    WebKit::WebMediaStream local_stream;
     local_stream.initialize(UTF8ToUTF16(stream_label), audio_sources,
                             video_sources);
     local_stream.setExtraData(new MediaStreamExtraData(native_stream));
     return local_stream;
   }
 
   // Creates a remote MediaStream and adds it to the mocked native
   // peer connection.
   scoped_refptr<webrtc::MediaStreamInterface>
   AddRemoteMockMediaStream(const std::string& stream_label,
@@ skipping 93 matching lines @@
   WebKit::WebRTCICECandidate candidate;
   candidate.initialize(kDummySdp, "mid", 1);
   EXPECT_TRUE(pc_handler_->addICECandidate(candidate));
   EXPECT_EQ(kDummySdp, mock_peer_connection_->ice_sdp());
   EXPECT_EQ(1, mock_peer_connection_->sdp_mline_index());
   EXPECT_EQ("mid", mock_peer_connection_->sdp_mid());
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, addAndRemoveStream) {
   std::string stream_label = "local_stream";
-  WebKit::WebMediaStreamDescriptor local_stream(
+  WebKit::WebMediaStream local_stream(
       CreateLocalMediaStream(stream_label));
   WebKit::WebMediaConstraints constraints;
 
   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());
   EXPECT_EQ(1u,
       mock_peer_connection_->local_streams()->at(0)->video_tracks()->count());
 
   pc_handler_->removeStream(local_stream);
   EXPECT_EQ(0u, mock_peer_connection_->local_streams()->count());
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, GetStatsNoSelector) {
   scoped_refptr<MockRTCStatsRequest> request(
       new talk_base::RefCountedObject<MockRTCStatsRequest>());
   pc_handler_->getStats(request.get());
   // Note that callback gets executed synchronously by mock.
   ASSERT_TRUE(request->result());
   EXPECT_LT(1, request->result()->report_count());
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, GetStatsWithSelector) {
   std::string stream_label = "local_stream";
-  WebKit::WebMediaStreamDescriptor local_stream(
+  WebKit::WebMediaStream local_stream(
       CreateLocalMediaStream(stream_label));
   WebKit::WebMediaConstraints constraints;
   pc_handler_->addStream(local_stream, constraints);
-  WebKit::WebVector<WebKit::WebMediaStreamComponent> components;
+  WebKit::WebVector<WebKit::WebMediaStreamTrack> components;
   local_stream.audioSources(components);
   ASSERT_LE(1ul, components.size());
 
   scoped_refptr<MockRTCStatsRequest> request(
       new talk_base::RefCountedObject<MockRTCStatsRequest>());
   request->setSelector(local_stream, components[0]);
   pc_handler_->getStats(request.get());
   EXPECT_EQ(1, request->result()->report_count());
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, GetStatsAfterStop) {
   scoped_refptr<MockRTCStatsRequest> request(
       new talk_base::RefCountedObject<MockRTCStatsRequest>());
   pc_handler_->stop();
   pc_handler_->getStats(request.get());
   // Note that callback gets executed synchronously by mock.
   ASSERT_TRUE(request->result());
   // Note - returning no stats is a temporary workaround.
   EXPECT_EQ(0, request->result()->report_count());
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, GetStatsWithBadSelector) {
   // The setup is the same as above, but the stream is not added to the
   // PeerConnection.
   std::string stream_label = "local_stream_2";
-  WebKit::WebMediaStreamDescriptor local_stream(
+  WebKit::WebMediaStream local_stream(
       CreateLocalMediaStream(stream_label));
   WebKit::WebMediaConstraints constraints;
-  WebKit::WebVector<WebKit::WebMediaStreamComponent> components;
+  WebKit::WebVector<WebKit::WebMediaStreamTrack> components;
   local_stream.audioSources(components);
-  WebKit::WebMediaStreamComponent component = components[0];
+  WebKit::WebMediaStreamTrack component = components[0];
   EXPECT_EQ(0u, mock_peer_connection_->local_streams()->count());
 
   scoped_refptr<MockRTCStatsRequest> request(
       new talk_base::RefCountedObject<MockRTCStatsRequest>());
   request->setSelector(local_stream, component);
   pc_handler_->getStats(request.get());
   EXPECT_EQ(0, request->result()->report_count());
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, OnStateChange) {
@@ skipping 107 matching lines @@
 
 TEST_F(RTCPeerConnectionHandlerTest, CreateDataChannel) {
   WebKit::WebString label = "d1";
   scoped_ptr<WebKit::WebRTCDataChannelHandler> channel(
       pc_handler_->createDataChannel("d1", true));
   EXPECT_TRUE(channel.get() != NULL);
   EXPECT_EQ(label, channel->label());
 }
 
 }  // namespace content