Correct stats for RTCPeerConnectionStats.dataChannels[Opened/Closed].

webrtc/api/datachannel_unittest.cc

 /*
  *  Copyright 2013 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 76 matching lines @@
     observer_.reset(new FakeDataChannelObserver());
     webrtc_data_channel_->RegisterObserver(observer_.get());
   }
 
   webrtc::InternalDataChannelInit init_;
   std::unique_ptr<FakeDataChannelProvider> provider_;
   std::unique_ptr<FakeDataChannelObserver> observer_;
   rtc::scoped_refptr<DataChannel> webrtc_data_channel_;
 };
 
+class StateSignalsListener : public sigslot::has_slots<> {
+ public:
+  int opened_count() const { return opened_count_; }
+  int closed_count() const { return closed_count_; }
+
+  void OnSignalOpened(DataChannel* data_channel) {
+    ++opened_count_;
+  }
+
+  void OnSignalClosed(DataChannel* data_channel) {
+    ++closed_count_;
+  }
+
+ private:
+  int opened_count_ = 0;
+  int closed_count_ = 0;
+};
+
 // Verifies that the data channel is connected to the transport after creation.
 TEST_F(SctpDataChannelTest, ConnectedToTransportOnCreated) {
   provider_->set_transport_available(true);
   rtc::scoped_refptr<DataChannel> dc =
       DataChannel::Create(provider_.get(), cricket::DCT_SCTP, "test1", init_);
 
   EXPECT_TRUE(provider_->IsConnected(dc.get()));
   // The sid is not set yet, so it should not have added the streams.
   EXPECT_FALSE(provider_->IsSendStreamAdded(dc->id()));
   EXPECT_FALSE(provider_->IsRecvStreamAdded(dc->id()));
 
   dc->SetSctpSid(0);
   EXPECT_TRUE(provider_->IsSendStreamAdded(dc->id()));
   EXPECT_TRUE(provider_->IsRecvStreamAdded(dc->id()));
 }
 
 // Verifies that the data channel is connected to the transport if the transport
 // is not available initially and becomes available later.
 TEST_F(SctpDataChannelTest, ConnectedAfterTransportBecomesAvailable) {
   EXPECT_FALSE(provider_->IsConnected(webrtc_data_channel_.get()));
 
   provider_->set_transport_available(true);
   webrtc_data_channel_->OnTransportChannelCreated();
   EXPECT_TRUE(provider_->IsConnected(webrtc_data_channel_.get()));
 }
 
 // Tests the state of the data channel.
 TEST_F(SctpDataChannelTest, StateTransition) {
+  StateSignalsListener state_signals_listener;
+  webrtc_data_channel_->SignalOpened.connect(
+      &state_signals_listener, &StateSignalsListener::OnSignalOpened);
+  webrtc_data_channel_->SignalClosed.connect(
+      &state_signals_listener, &StateSignalsListener::OnSignalClosed);
   EXPECT_EQ(webrtc::DataChannelInterface::kConnecting,
             webrtc_data_channel_->state());
+  EXPECT_EQ(state_signals_listener.opened_count(), 0);
+  EXPECT_EQ(state_signals_listener.closed_count(), 0);
   SetChannelReady();
 
   EXPECT_EQ(webrtc::DataChannelInterface::kOpen, webrtc_data_channel_->state());
+  EXPECT_EQ(state_signals_listener.opened_count(), 1);
+  EXPECT_EQ(state_signals_listener.closed_count(), 0);
   webrtc_data_channel_->Close();
   EXPECT_EQ(webrtc::DataChannelInterface::kClosed,
             webrtc_data_channel_->state());
+  EXPECT_EQ(state_signals_listener.opened_count(), 1);
+  EXPECT_EQ(state_signals_listener.closed_count(), 1);
   // Verifies that it's disconnected from the transport.
   EXPECT_FALSE(provider_->IsConnected(webrtc_data_channel_.get()));
 }
 
 // Tests that DataChannel::buffered_amount() is correct after the channel is
 // blocked.
 TEST_F(SctpDataChannelTest, BufferedAmountWhenBlocked) {
   AddObserver();
   SetChannelReady();
   webrtc::DataBuffer buffer("abcd");
@@ skipping 533 matching lines @@
   EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_CLIENT, &allocated_id));
   EXPECT_EQ(even_id, allocated_id);
 
   // Verifies that used higher ids are not reused.
   EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_SERVER, &allocated_id));
   EXPECT_EQ(odd_id + 6, allocated_id);
 
   EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_CLIENT, &allocated_id));
   EXPECT_EQ(even_id + 6, allocated_id);
 }