src/content/renderer/media/webrtc/media_stream_track_metrics_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/renderer/media/webrtc/media_stream_track_metrics.h"
   6 #include "content/renderer/media/webrtc/mock_peer_connection_dependency_factory.h"
   7 #include "testing/gmock/include/gmock/gmock.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9 #include "third_party/libjingle/source/talk/app/webrtc/mediastreaminterface.h"
  10
  11 using webrtc::AudioSourceInterface;
  12 using webrtc::AudioTrackInterface;
  13 using webrtc::AudioTrackSinkInterface;
  14 using webrtc::MediaStreamInterface;
  15 using webrtc::ObserverInterface;
  16 using webrtc::PeerConnectionInterface;
  17 using webrtc::VideoRendererInterface;
  18 using webrtc::VideoSourceInterface;
  19 using webrtc::VideoTrackInterface;
  20
  21 namespace content {
  22
  23 // A very simple mock that implements only the id() method.
  24 class MockAudioTrackInterface : public AudioTrackInterface {
  25  public:
  26   explicit MockAudioTrackInterface(const std::string& id) : id_(id) {}
  27   virtual ~MockAudioTrackInterface() {}
  28
  29   virtual std::string id() const OVERRIDE { return id_; }
  30
  31   MOCK_METHOD1(RegisterObserver, void(ObserverInterface*));
  32   MOCK_METHOD1(UnregisterObserver, void(ObserverInterface*));
  33   MOCK_CONST_METHOD0(kind, std::string());
  34   MOCK_CONST_METHOD0(enabled, bool());
  35   MOCK_CONST_METHOD0(state, TrackState());
  36   MOCK_METHOD1(set_enabled, bool(bool));
  37   MOCK_METHOD1(set_state, bool(TrackState));
  38   MOCK_CONST_METHOD0(GetSource, AudioSourceInterface*());
  39   MOCK_METHOD1(AddSink, void(AudioTrackSinkInterface*));
  40   MOCK_METHOD1(RemoveSink, void(AudioTrackSinkInterface*));
  41
  42  private:
  43   std::string id_;
  44 };
  45
  46 // A very simple mock that implements only the id() method.
  47 class MockVideoTrackInterface : public VideoTrackInterface {
  48  public:
  49   explicit MockVideoTrackInterface(const std::string& id) : id_(id) {}
  50   virtual ~MockVideoTrackInterface() {}
  51
  52   virtual std::string id() const OVERRIDE { return id_; }
  53
  54   MOCK_METHOD1(RegisterObserver, void(ObserverInterface*));
  55   MOCK_METHOD1(UnregisterObserver, void(ObserverInterface*));
  56   MOCK_CONST_METHOD0(kind, std::string());
  57   MOCK_CONST_METHOD0(enabled, bool());
  58   MOCK_CONST_METHOD0(state, TrackState());
  59   MOCK_METHOD1(set_enabled, bool(bool));
  60   MOCK_METHOD1(set_state, bool(TrackState));
  61   MOCK_METHOD1(AddRenderer, void(VideoRendererInterface*));
  62   MOCK_METHOD1(RemoveRenderer, void(VideoRendererInterface*));
  63   MOCK_CONST_METHOD0(GetSource, VideoSourceInterface*());
  64
  65  private:
  66   std::string id_;
  67 };
  68
  69 class MockMediaStreamTrackMetrics : public MediaStreamTrackMetrics {
  70  public:
  71   virtual ~MockMediaStreamTrackMetrics() {}
  72
  73   MOCK_METHOD4(SendLifetimeMessage,
  74                void(const std::string&, TrackType, LifetimeEvent, StreamType));
  75
  76   using MediaStreamTrackMetrics::MakeUniqueIdImpl;
  77 };
  78
  79 class MediaStreamTrackMetricsTest : public testing::Test {
  80  public:
  81   virtual void SetUp() OVERRIDE {
  82     metrics_.reset(new MockMediaStreamTrackMetrics());
  83     stream_ = new rtc::RefCountedObject<MockMediaStream>("stream");
  84   }
  85
  86   virtual void TearDown() OVERRIDE {
  87     metrics_.reset();
  88     stream_ = NULL;
  89   }
  90
  91   scoped_refptr<MockAudioTrackInterface> MakeAudioTrack(std::string id) {
  92     return new rtc::RefCountedObject<MockAudioTrackInterface>(id);
  93   }
  94
  95   scoped_refptr<MockVideoTrackInterface> MakeVideoTrack(std::string id) {
  96     return new rtc::RefCountedObject<MockVideoTrackInterface>(id);
  97   }
  98
  99   scoped_ptr<MockMediaStreamTrackMetrics> metrics_;
 100   scoped_refptr<MediaStreamInterface> stream_;
 101 };
 102
 103 TEST_F(MediaStreamTrackMetricsTest, MakeUniqueId) {
 104   // The important testable properties of the unique ID are that it
 105   // should differ when any of the three constituents differ
 106   // (PeerConnection pointer, track ID, remote or not. Also, testing
 107   // that the implementation does not discard the upper 32 bits of the
 108   // PeerConnection pointer is important.
 109   //
 110   // The important hard-to-test property is that the ID be generated
 111   // using a hash function with virtually zero chance of
 112   // collisions. We don't test this, we rely on MD5 having this
 113   // property.
 114
 115   // Lower 32 bits the same, upper 32 differ.
 116   EXPECT_NE(
 117       metrics_->MakeUniqueIdImpl(
 118           0x1000000000000001, "x", MediaStreamTrackMetrics::RECEIVED_STREAM),
 119       metrics_->MakeUniqueIdImpl(
 120           0x2000000000000001, "x", MediaStreamTrackMetrics::RECEIVED_STREAM));
 121
 122   // Track ID differs.
 123   EXPECT_NE(metrics_->MakeUniqueIdImpl(
 124                 42, "x", MediaStreamTrackMetrics::RECEIVED_STREAM),
 125             metrics_->MakeUniqueIdImpl(
 126                 42, "y", MediaStreamTrackMetrics::RECEIVED_STREAM));
 127
 128   // Remove vs. local track differs.
 129   EXPECT_NE(metrics_->MakeUniqueIdImpl(
 130                 42, "x", MediaStreamTrackMetrics::RECEIVED_STREAM),
 131             metrics_->MakeUniqueIdImpl(
 132                 42, "x", MediaStreamTrackMetrics::SENT_STREAM));
 133 }
 134
 135 TEST_F(MediaStreamTrackMetricsTest, BasicRemoteStreams) {
 136   scoped_refptr<MockAudioTrackInterface> audio(MakeAudioTrack("audio"));
 137   scoped_refptr<MockVideoTrackInterface> video(MakeVideoTrack("video"));
 138   stream_->AddTrack(audio.get());
 139   stream_->AddTrack(video.get());
 140   metrics_->AddStream(MediaStreamTrackMetrics::RECEIVED_STREAM, stream_.get());
 141
 142   EXPECT_CALL(*metrics_,
 143               SendLifetimeMessage("audio",
 144                                   MediaStreamTrackMetrics::AUDIO_TRACK,
 145                                   MediaStreamTrackMetrics::CONNECTED,
 146                                   MediaStreamTrackMetrics::RECEIVED_STREAM));
 147   EXPECT_CALL(*metrics_,
 148               SendLifetimeMessage("video",
 149                                   MediaStreamTrackMetrics::VIDEO_TRACK,
 150                                   MediaStreamTrackMetrics::CONNECTED,
 151                                   MediaStreamTrackMetrics::RECEIVED_STREAM));
 152   metrics_->IceConnectionChange(
 153       PeerConnectionInterface::kIceConnectionConnected);
 154
 155   EXPECT_CALL(*metrics_,
 156               SendLifetimeMessage("audio",
 157                                   MediaStreamTrackMetrics::AUDIO_TRACK,
 158                                   MediaStreamTrackMetrics::DISCONNECTED,
 159                                   MediaStreamTrackMetrics::RECEIVED_STREAM));
 160   EXPECT_CALL(*metrics_,
 161               SendLifetimeMessage("video",
 162                                   MediaStreamTrackMetrics::VIDEO_TRACK,
 163                                   MediaStreamTrackMetrics::DISCONNECTED,
 164                                   MediaStreamTrackMetrics::RECEIVED_STREAM));
 165   metrics_->IceConnectionChange(
 166       PeerConnectionInterface::kIceConnectionDisconnected);
 167 }
 168
 169 TEST_F(MediaStreamTrackMetricsTest, BasicLocalStreams) {
 170   scoped_refptr<MockAudioTrackInterface> audio(MakeAudioTrack("audio"));
 171   scoped_refptr<MockVideoTrackInterface> video(MakeVideoTrack("video"));
 172   stream_->AddTrack(audio.get());
 173   stream_->AddTrack(video.get());
 174   metrics_->AddStream(MediaStreamTrackMetrics::SENT_STREAM, stream_.get());
 175
 176   EXPECT_CALL(*metrics_,
 177               SendLifetimeMessage("audio",
 178                                   MediaStreamTrackMetrics::AUDIO_TRACK,
 179                                   MediaStreamTrackMetrics::CONNECTED,
 180                                   MediaStreamTrackMetrics::SENT_STREAM));
 181   EXPECT_CALL(*metrics_,
 182               SendLifetimeMessage("video",
 183                                   MediaStreamTrackMetrics::VIDEO_TRACK,
 184                                   MediaStreamTrackMetrics::CONNECTED,
 185                                   MediaStreamTrackMetrics::SENT_STREAM));
 186   metrics_->IceConnectionChange(
 187       PeerConnectionInterface::kIceConnectionConnected);
 188
 189   EXPECT_CALL(*metrics_,
 190               SendLifetimeMessage("audio",
 191                                   MediaStreamTrackMetrics::AUDIO_TRACK,
 192                                   MediaStreamTrackMetrics::DISCONNECTED,
 193                                   MediaStreamTrackMetrics::SENT_STREAM));
 194   EXPECT_CALL(*metrics_,
 195               SendLifetimeMessage("video",
 196                                   MediaStreamTrackMetrics::VIDEO_TRACK,
 197                                   MediaStreamTrackMetrics::DISCONNECTED,
 198                                   MediaStreamTrackMetrics::SENT_STREAM));
 199   metrics_->IceConnectionChange(PeerConnectionInterface::kIceConnectionFailed);
 200 }
 201
 202 TEST_F(MediaStreamTrackMetricsTest, LocalStreamAddedAferIceConnect) {
 203   metrics_->IceConnectionChange(
 204         PeerConnectionInterface::kIceConnectionConnected);
 205
 206   EXPECT_CALL(*metrics_,
 207               SendLifetimeMessage("audio",
 208                                   MediaStreamTrackMetrics::AUDIO_TRACK,
 209                                   MediaStreamTrackMetrics::CONNECTED,
 210                                   MediaStreamTrackMetrics::SENT_STREAM));
 211   EXPECT_CALL(*metrics_,
 212               SendLifetimeMessage("video",
 213                                   MediaStreamTrackMetrics::VIDEO_TRACK,
 214                                   MediaStreamTrackMetrics::CONNECTED,
 215                                   MediaStreamTrackMetrics::SENT_STREAM));
 216
 217   scoped_refptr<MockAudioTrackInterface> audio(MakeAudioTrack("audio"));
 218   scoped_refptr<MockVideoTrackInterface> video(MakeVideoTrack("video"));
 219   stream_->AddTrack(audio.get());
 220   stream_->AddTrack(video.get());
 221   metrics_->AddStream(MediaStreamTrackMetrics::SENT_STREAM, stream_.get());
 222 }
 223
 224 TEST_F(MediaStreamTrackMetricsTest, RemoteStreamAddedAferIceConnect) {
 225   metrics_->IceConnectionChange(
 226         PeerConnectionInterface::kIceConnectionConnected);
 227
 228   EXPECT_CALL(*metrics_,
 229               SendLifetimeMessage("audio",
 230                                   MediaStreamTrackMetrics::AUDIO_TRACK,
 231                                   MediaStreamTrackMetrics::CONNECTED,
 232                                   MediaStreamTrackMetrics::RECEIVED_STREAM));
 233   EXPECT_CALL(*metrics_,
 234               SendLifetimeMessage("video",
 235                                   MediaStreamTrackMetrics::VIDEO_TRACK,
 236                                   MediaStreamTrackMetrics::CONNECTED,
 237                                   MediaStreamTrackMetrics::RECEIVED_STREAM));
 238
 239   scoped_refptr<MockAudioTrackInterface> audio(MakeAudioTrack("audio"));
 240   scoped_refptr<MockVideoTrackInterface> video(MakeVideoTrack("video"));
 241   stream_->AddTrack(audio.get());
 242   stream_->AddTrack(video.get());
 243   metrics_->AddStream(MediaStreamTrackMetrics::RECEIVED_STREAM, stream_.get());
 244 }
 245
 246 TEST_F(MediaStreamTrackMetricsTest, RemoteStreamTrackAdded) {
 247   scoped_refptr<MockAudioTrackInterface> initial(MakeAudioTrack("initial"));
 248   scoped_refptr<MockAudioTrackInterface> added(MakeAudioTrack("added"));
 249   stream_->AddTrack(initial.get());
 250   metrics_->AddStream(MediaStreamTrackMetrics::RECEIVED_STREAM, stream_.get());
 251
 252   EXPECT_CALL(*metrics_,
 253               SendLifetimeMessage("initial",
 254                                   MediaStreamTrackMetrics::AUDIO_TRACK,
 255                                   MediaStreamTrackMetrics::CONNECTED,
 256                                   MediaStreamTrackMetrics::RECEIVED_STREAM));
 257   metrics_->IceConnectionChange(
 258       PeerConnectionInterface::kIceConnectionConnected);
 259
 260   EXPECT_CALL(*metrics_,
 261               SendLifetimeMessage("added",
 262                                   MediaStreamTrackMetrics::AUDIO_TRACK,
 263                                   MediaStreamTrackMetrics::CONNECTED,
 264                                   MediaStreamTrackMetrics::RECEIVED_STREAM));
 265   stream_->AddTrack(added.get());
 266
 267   EXPECT_CALL(*metrics_,
 268               SendLifetimeMessage("initial",
 269                                   MediaStreamTrackMetrics::AUDIO_TRACK,
 270                                   MediaStreamTrackMetrics::DISCONNECTED,
 271                                   MediaStreamTrackMetrics::RECEIVED_STREAM));
 272   EXPECT_CALL(*metrics_,
 273               SendLifetimeMessage("added",
 274                                   MediaStreamTrackMetrics::AUDIO_TRACK,
 275                                   MediaStreamTrackMetrics::DISCONNECTED,
 276                                   MediaStreamTrackMetrics::RECEIVED_STREAM));
 277   metrics_->IceConnectionChange(PeerConnectionInterface::kIceConnectionFailed);
 278 }
 279
 280 TEST_F(MediaStreamTrackMetricsTest, LocalStreamTrackRemoved) {
 281   scoped_refptr<MockAudioTrackInterface> first(MakeAudioTrack("first"));
 282   scoped_refptr<MockAudioTrackInterface> second(MakeAudioTrack("second"));
 283   stream_->AddTrack(first.get());
 284   stream_->AddTrack(second.get());
 285   metrics_->AddStream(MediaStreamTrackMetrics::SENT_STREAM, stream_.get());
 286
 287   EXPECT_CALL(*metrics_,
 288               SendLifetimeMessage("first",
 289                                   MediaStreamTrackMetrics::AUDIO_TRACK,
 290                                   MediaStreamTrackMetrics::CONNECTED,
 291                                   MediaStreamTrackMetrics::SENT_STREAM));
 292   EXPECT_CALL(*metrics_,
 293               SendLifetimeMessage("second",
 294                                   MediaStreamTrackMetrics::AUDIO_TRACK,
 295                                   MediaStreamTrackMetrics::CONNECTED,
 296                                   MediaStreamTrackMetrics::SENT_STREAM));
 297   metrics_->IceConnectionChange(
 298       PeerConnectionInterface::kIceConnectionConnected);
 299
 300   EXPECT_CALL(*metrics_,
 301               SendLifetimeMessage("first",
 302                                   MediaStreamTrackMetrics::AUDIO_TRACK,
 303                                   MediaStreamTrackMetrics::DISCONNECTED,
 304                                   MediaStreamTrackMetrics::SENT_STREAM));
 305   stream_->RemoveTrack(first.get());
 306
 307   EXPECT_CALL(*metrics_,
 308               SendLifetimeMessage("second",
 309                                   MediaStreamTrackMetrics::AUDIO_TRACK,
 310                                   MediaStreamTrackMetrics::DISCONNECTED,
 311                                   MediaStreamTrackMetrics::SENT_STREAM));
 312   metrics_->IceConnectionChange(PeerConnectionInterface::kIceConnectionFailed);
 313 }
 314
 315 TEST_F(MediaStreamTrackMetricsTest, LocalStreamModificationsBeforeAndAfter) {
 316   scoped_refptr<MockAudioTrackInterface> first(MakeAudioTrack("first"));
 317   scoped_refptr<MockAudioTrackInterface> second(MakeAudioTrack("second"));
 318   stream_->AddTrack(first.get());
 319   metrics_->AddStream(MediaStreamTrackMetrics::SENT_STREAM, stream_.get());
 320
 321   // This gets added after we start observing, but no lifetime message
 322   // should be sent at this point since the call is not connected. It
 323   // should get sent only once it gets connected.
 324   stream_->AddTrack(second.get());
 325
 326   EXPECT_CALL(*metrics_,
 327               SendLifetimeMessage("first",
 328                                   MediaStreamTrackMetrics::AUDIO_TRACK,
 329                                   MediaStreamTrackMetrics::CONNECTED,
 330                                   MediaStreamTrackMetrics::SENT_STREAM));
 331   EXPECT_CALL(*metrics_,
 332               SendLifetimeMessage("second",
 333                                   MediaStreamTrackMetrics::AUDIO_TRACK,
 334                                   MediaStreamTrackMetrics::CONNECTED,
 335                                   MediaStreamTrackMetrics::SENT_STREAM));
 336   metrics_->IceConnectionChange(
 337       PeerConnectionInterface::kIceConnectionConnected);
 338
 339   EXPECT_CALL(*metrics_,
 340               SendLifetimeMessage("first",
 341                                   MediaStreamTrackMetrics::AUDIO_TRACK,
 342                                   MediaStreamTrackMetrics::DISCONNECTED,
 343                                   MediaStreamTrackMetrics::SENT_STREAM));
 344   EXPECT_CALL(*metrics_,
 345               SendLifetimeMessage("second",
 346                                   MediaStreamTrackMetrics::AUDIO_TRACK,
 347                                   MediaStreamTrackMetrics::DISCONNECTED,
 348                                   MediaStreamTrackMetrics::SENT_STREAM));
 349   metrics_->IceConnectionChange(PeerConnectionInterface::kIceConnectionFailed);
 350
 351   // This happens after the call is disconnected so no lifetime
 352   // message should be sent.
 353   stream_->RemoveTrack(first.get());
 354 }
 355
 356 TEST_F(MediaStreamTrackMetricsTest, RemoteStreamMultipleDisconnects) {
 357   scoped_refptr<MockAudioTrackInterface> audio(MakeAudioTrack("audio"));
 358   stream_->AddTrack(audio.get());
 359   metrics_->AddStream(MediaStreamTrackMetrics::RECEIVED_STREAM, stream_.get());
 360
 361   EXPECT_CALL(*metrics_,
 362               SendLifetimeMessage("audio",
 363                                   MediaStreamTrackMetrics::AUDIO_TRACK,
 364                                   MediaStreamTrackMetrics::CONNECTED,
 365                                   MediaStreamTrackMetrics::RECEIVED_STREAM));
 366   metrics_->IceConnectionChange(
 367       PeerConnectionInterface::kIceConnectionConnected);
 368
 369   EXPECT_CALL(*metrics_,
 370               SendLifetimeMessage("audio",
 371                                   MediaStreamTrackMetrics::AUDIO_TRACK,
 372                                   MediaStreamTrackMetrics::DISCONNECTED,
 373                                   MediaStreamTrackMetrics::RECEIVED_STREAM));
 374   metrics_->IceConnectionChange(
 375       PeerConnectionInterface::kIceConnectionDisconnected);
 376   metrics_->IceConnectionChange(PeerConnectionInterface::kIceConnectionFailed);
 377   stream_->RemoveTrack(audio.get());
 378 }
 379
 380 TEST_F(MediaStreamTrackMetricsTest, RemoteStreamConnectDisconnectTwice) {
 381   scoped_refptr<MockAudioTrackInterface> audio(MakeAudioTrack("audio"));
 382   stream_->AddTrack(audio.get());
 383   metrics_->AddStream(MediaStreamTrackMetrics::RECEIVED_STREAM, stream_.get());
 384
 385   for (size_t i = 0; i < 2; ++i) {
 386     EXPECT_CALL(*metrics_,
 387                 SendLifetimeMessage("audio",
 388                                     MediaStreamTrackMetrics::AUDIO_TRACK,
 389                                     MediaStreamTrackMetrics::CONNECTED,
 390                                     MediaStreamTrackMetrics::RECEIVED_STREAM));
 391     metrics_->IceConnectionChange(
 392         PeerConnectionInterface::kIceConnectionConnected);
 393
 394     EXPECT_CALL(*metrics_,
 395                 SendLifetimeMessage("audio",
 396                                     MediaStreamTrackMetrics::AUDIO_TRACK,
 397                                     MediaStreamTrackMetrics::DISCONNECTED,
 398                                     MediaStreamTrackMetrics::RECEIVED_STREAM));
 399     metrics_->IceConnectionChange(
 400         PeerConnectionInterface::kIceConnectionDisconnected);
 401   }
 402
 403   stream_->RemoveTrack(audio.get());
 404 }
 405
 406 TEST_F(MediaStreamTrackMetricsTest, LocalStreamRemovedNoDisconnect) {
 407   scoped_refptr<MockAudioTrackInterface> audio(MakeAudioTrack("audio"));
 408   scoped_refptr<MockVideoTrackInterface> video(MakeVideoTrack("video"));
 409   stream_->AddTrack(audio.get());
 410   stream_->AddTrack(video.get());
 411   metrics_->AddStream(MediaStreamTrackMetrics::SENT_STREAM, stream_.get());
 412
 413   EXPECT_CALL(*metrics_,
 414               SendLifetimeMessage("audio",
 415                                   MediaStreamTrackMetrics::AUDIO_TRACK,
 416                                   MediaStreamTrackMetrics::CONNECTED,
 417                                   MediaStreamTrackMetrics::SENT_STREAM));
 418   EXPECT_CALL(*metrics_,
 419               SendLifetimeMessage("video",
 420                                   MediaStreamTrackMetrics::VIDEO_TRACK,
 421                                   MediaStreamTrackMetrics::CONNECTED,
 422                                   MediaStreamTrackMetrics::SENT_STREAM));
 423   metrics_->IceConnectionChange(
 424       PeerConnectionInterface::kIceConnectionConnected);
 425
 426   EXPECT_CALL(*metrics_,
 427               SendLifetimeMessage("audio",
 428                                   MediaStreamTrackMetrics::AUDIO_TRACK,
 429                                   MediaStreamTrackMetrics::DISCONNECTED,
 430                                   MediaStreamTrackMetrics::SENT_STREAM));
 431   EXPECT_CALL(*metrics_,
 432               SendLifetimeMessage("video",
 433                                   MediaStreamTrackMetrics::VIDEO_TRACK,
 434                                   MediaStreamTrackMetrics::DISCONNECTED,
 435                                   MediaStreamTrackMetrics::SENT_STREAM));
 436   metrics_->RemoveStream(MediaStreamTrackMetrics::SENT_STREAM, stream_.get());
 437 }
 438
 439 TEST_F(MediaStreamTrackMetricsTest, LocalStreamLargerTest) {
 440   scoped_refptr<MockAudioTrackInterface> audio1(MakeAudioTrack("audio1"));
 441   scoped_refptr<MockAudioTrackInterface> audio2(MakeAudioTrack("audio2"));
 442   scoped_refptr<MockAudioTrackInterface> audio3(MakeAudioTrack("audio3"));
 443   scoped_refptr<MockVideoTrackInterface> video1(MakeVideoTrack("video1"));
 444   scoped_refptr<MockVideoTrackInterface> video2(MakeVideoTrack("video2"));
 445   scoped_refptr<MockVideoTrackInterface> video3(MakeVideoTrack("video3"));
 446   stream_->AddTrack(audio1.get());
 447   stream_->AddTrack(video1.get());
 448   metrics_->AddStream(MediaStreamTrackMetrics::SENT_STREAM, stream_.get());
 449
 450   EXPECT_CALL(*metrics_,
 451               SendLifetimeMessage("audio1",
 452                                   MediaStreamTrackMetrics::AUDIO_TRACK,
 453                                   MediaStreamTrackMetrics::CONNECTED,
 454                                   MediaStreamTrackMetrics::SENT_STREAM));
 455   EXPECT_CALL(*metrics_,
 456               SendLifetimeMessage("video1",
 457                                   MediaStreamTrackMetrics::VIDEO_TRACK,
 458                                   MediaStreamTrackMetrics::CONNECTED,
 459                                   MediaStreamTrackMetrics::SENT_STREAM));
 460   metrics_->IceConnectionChange(
 461       PeerConnectionInterface::kIceConnectionConnected);
 462
 463   EXPECT_CALL(*metrics_,
 464               SendLifetimeMessage("audio2",
 465                                   MediaStreamTrackMetrics::AUDIO_TRACK,
 466                                   MediaStreamTrackMetrics::CONNECTED,
 467                                   MediaStreamTrackMetrics::SENT_STREAM));
 468   stream_->AddTrack(audio2.get());
 469   EXPECT_CALL(*metrics_,
 470               SendLifetimeMessage("video2",
 471                                   MediaStreamTrackMetrics::VIDEO_TRACK,
 472                                   MediaStreamTrackMetrics::CONNECTED,
 473                                   MediaStreamTrackMetrics::SENT_STREAM));
 474   stream_->AddTrack(video2.get());
 475
 476   EXPECT_CALL(*metrics_,
 477               SendLifetimeMessage("audio1",
 478                                   MediaStreamTrackMetrics::AUDIO_TRACK,
 479                                   MediaStreamTrackMetrics::DISCONNECTED,
 480                                   MediaStreamTrackMetrics::SENT_STREAM));
 481   stream_->RemoveTrack(audio1.get());
 482
 483   EXPECT_CALL(*metrics_,
 484               SendLifetimeMessage("audio3",
 485                                   MediaStreamTrackMetrics::AUDIO_TRACK,
 486                                   MediaStreamTrackMetrics::CONNECTED,
 487                                   MediaStreamTrackMetrics::SENT_STREAM));
 488   stream_->AddTrack(audio3.get());
 489   EXPECT_CALL(*metrics_,
 490               SendLifetimeMessage("video3",
 491                                   MediaStreamTrackMetrics::VIDEO_TRACK,
 492                                   MediaStreamTrackMetrics::CONNECTED,
 493                                   MediaStreamTrackMetrics::SENT_STREAM));
 494   stream_->AddTrack(video3.get());
 495
 496   // Add back audio1
 497   EXPECT_CALL(*metrics_,
 498               SendLifetimeMessage("audio1",
 499                                   MediaStreamTrackMetrics::AUDIO_TRACK,
 500                                   MediaStreamTrackMetrics::CONNECTED,
 501                                   MediaStreamTrackMetrics::SENT_STREAM));
 502   stream_->AddTrack(audio1.get());
 503
 504   EXPECT_CALL(*metrics_,
 505               SendLifetimeMessage("audio2",
 506                                   MediaStreamTrackMetrics::AUDIO_TRACK,
 507                                   MediaStreamTrackMetrics::DISCONNECTED,
 508                                   MediaStreamTrackMetrics::SENT_STREAM));
 509   stream_->RemoveTrack(audio2.get());
 510   EXPECT_CALL(*metrics_,
 511               SendLifetimeMessage("video2",
 512                                   MediaStreamTrackMetrics::VIDEO_TRACK,
 513                                   MediaStreamTrackMetrics::DISCONNECTED,
 514                                   MediaStreamTrackMetrics::SENT_STREAM));
 515   stream_->RemoveTrack(video2.get());
 516
 517   EXPECT_CALL(*metrics_,
 518               SendLifetimeMessage("audio1",
 519                                   MediaStreamTrackMetrics::AUDIO_TRACK,
 520                                   MediaStreamTrackMetrics::DISCONNECTED,
 521                                   MediaStreamTrackMetrics::SENT_STREAM));
 522   stream_->RemoveTrack(audio1.get());
 523   EXPECT_CALL(*metrics_,
 524               SendLifetimeMessage("video1",
 525                                   MediaStreamTrackMetrics::VIDEO_TRACK,
 526                                   MediaStreamTrackMetrics::DISCONNECTED,
 527                                   MediaStreamTrackMetrics::SENT_STREAM));
 528   stream_->RemoveTrack(video1.get());
 529
 530   EXPECT_CALL(*metrics_,
 531               SendLifetimeMessage("audio3",
 532                                   MediaStreamTrackMetrics::AUDIO_TRACK,
 533                                   MediaStreamTrackMetrics::DISCONNECTED,
 534                                   MediaStreamTrackMetrics::SENT_STREAM));
 535   EXPECT_CALL(*metrics_,
 536               SendLifetimeMessage("video3",
 537                                   MediaStreamTrackMetrics::VIDEO_TRACK,
 538                                   MediaStreamTrackMetrics::DISCONNECTED,
 539                                   MediaStreamTrackMetrics::SENT_STREAM));
 540   metrics_->RemoveStream(MediaStreamTrackMetrics::SENT_STREAM, stream_.get());
 541 }
 542
 543 }  // namespace content