Add UMA metrics for ICE regathering reasons.

webrtc/p2p/base/p2ptransportchannel_unittest.cc

 /*
  *  Copyright 2009 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.
  */
 
 #include <algorithm>
 #include <memory>
 
+#include "webrtc/api/fakemetricsobserver.h"
 #include "webrtc/p2p/base/fakeportallocator.h"
 #include "webrtc/p2p/base/p2ptransportchannel.h"
 #include "webrtc/p2p/base/testrelayserver.h"
 #include "webrtc/p2p/base/teststunserver.h"
 #include "webrtc/p2p/base/testturnserver.h"
 #include "webrtc/p2p/client/basicportallocator.h"
 #include "webrtc/base/dscp.h"
 #include "webrtc/base/fakeclock.h"
 #include "webrtc/base/fakenetwork.h"
 #include "webrtc/base/firewallsocketserver.h"
@@ skipping 167 matching lines @@
                        kSocksProxyAddrs[1]),
         force_relay_(false) {
     ep1_.role_ = ICEROLE_CONTROLLING;
     ep2_.role_ = ICEROLE_CONTROLLED;
 
     ServerAddresses stun_servers;
     stun_servers.insert(kStunAddr);
     ep1_.allocator_.reset(
         CreateBasicPortAllocator(&ep1_.network_manager_, stun_servers,
                                  kTurnUdpIntAddr, rtc::SocketAddress()));
+    ep1_.metrics_observer_ =
+        new rtc::RefCountedObject<webrtc::FakeMetricsObserver>();
+    ep1_.allocator_->set_metrics_observer(ep1_.metrics_observer_);
     ep2_.allocator_.reset(
         CreateBasicPortAllocator(&ep2_.network_manager_, stun_servers,
                                  kTurnUdpIntAddr, rtc::SocketAddress()));
+    ep2_.metrics_observer_ =
+        new rtc::RefCountedObject<webrtc::FakeMetricsObserver>();
+    ep2_.allocator_->set_metrics_observer(ep2_.metrics_observer_);
   }
 
  protected:
   enum Config {
     OPEN,                           // Open to the Internet
     NAT_FULL_CONE,                  // NAT, no filtering
     NAT_ADDR_RESTRICTED,            // NAT, must send to an addr to recv
     NAT_PORT_RESTRICTED,            // NAT, must send to an addr+port to recv
     NAT_SYMMETRIC,                  // NAT, endpoint-dependent bindings
     NAT_DOUBLE_CONE,                // Double NAT, both cone
@@ skipping 77 matching lines @@
     void OnRoleConflict(bool role_conflict) { role_conflict_ = role_conflict; }
     bool role_conflict() { return role_conflict_; }
     void SetAllocationStepDelay(uint32_t delay) {
       allocator_->set_step_delay(delay);
     }
     void SetAllowTcpListen(bool allow_tcp_listen) {
       allocator_->set_allow_tcp_listen(allow_tcp_listen);
     }
 
     rtc::FakeNetworkManager network_manager_;
+    // |metrics_observer_| should outlive |allocator_| as the former may be
+    // used by the latter.
+    rtc::scoped_refptr<webrtc::FakeMetricsObserver> metrics_observer_;
     std::unique_ptr<BasicPortAllocator> allocator_;
     ChannelData cd1_;
     ChannelData cd2_;
     IceRole role_;
     uint64_t tiebreaker_;
     bool role_conflict_;
     bool save_candidates_;
     std::vector<std::unique_ptr<CandidatesData>> saved_candidates_;
     bool ready_to_send_ = false;
   };
@@ skipping 98 matching lines @@
       return &ep1_;
     } else if (endpoint == 1) {
       return &ep2_;
     } else {
       return NULL;
     }
   }
   PortAllocator* GetAllocator(int endpoint) {
     return GetEndpoint(endpoint)->allocator_.get();
   }
+  webrtc::FakeMetricsObserver* GetMetricsObserver(int endpoint) {
+    return GetEndpoint(endpoint)->metrics_observer_;
+  }
   void AddAddress(int endpoint, const SocketAddress& addr) {
     GetEndpoint(endpoint)->network_manager_.AddInterface(addr);
   }
   void AddAddress(int endpoint,
                   const SocketAddress& addr,
                   const std::string& ifname,
                   rtc::AdapterType adapter_type) {
     GetEndpoint(endpoint)->network_manager_.AddInterface(addr, ifname,
                                                          adapter_type);
   }
@@ skipping 736 matching lines @@
   EXPECT_TRUE(best_conn_info->writable);
   EXPECT_FALSE(best_conn_info->timeout);
   EXPECT_EQ(10U, best_conn_info->sent_total_packets);
   EXPECT_EQ(0U, best_conn_info->sent_discarded_packets);
   EXPECT_EQ(10 * 36U, best_conn_info->sent_total_bytes);
   EXPECT_EQ(10 * 36U, best_conn_info->recv_total_bytes);
   EXPECT_GT(best_conn_info->rtt, 0U);
   DestroyChannels();
 }
 
+TEST_F(P2PTransportChannelTest,
+       TestIceRegatheringReasonIceRestartWhenDisconnected) {
+  rtc::ScopedFakeClock clock;
+  ConfigureEndpoints(OPEN, OPEN, kOnlyLocalPorts, kOnlyLocalPorts);
+
+  CreateChannels();
+  EXPECT_TRUE_SIMULATED_WAIT(ep1_ch1()->receiving() && ep1_ch1()->writable() &&
+                                 ep2_ch1()->receiving() &&
+                                 ep2_ch1()->writable(),
+                             kDefaultTimeout, clock);
+
+  // Drop all packets so that both channels become not writable.
+  fw()->AddRule(false, rtc::FP_ANY, rtc::FD_ANY, kPublicAddrs[0]);
+  const int kWriteTimeoutDelay = 6000;
+  EXPECT_TRUE_SIMULATED_WAIT(!ep1_ch1()->writable() && !ep2_ch1()->writable(),
+                             kWriteTimeoutDelay, clock);
+
+  ep1_ch1()->SetIceParameters(kIceParams[2]);
+  ep1_ch1()->SetRemoteIceParameters(kIceParams[3]);
+  ep1_ch1()->MaybeStartGathering();
+  EXPECT_EQ(1, GetMetricsObserver(0)->GetEnumCounter(
+                   webrtc::kEnumCounterIceRegatheringReason,
+                   static_cast<int>(
+                       IceRegatheringReason::ICE_RESTART_WHEN_DISCONNECTED)));
+
+  ep2_ch1()->SetIceParameters(kIceParams[3]);
+  ep2_ch1()->SetRemoteIceParameters(kIceParams[2]);
+  ep2_ch1()->MaybeStartGathering();
+  EXPECT_EQ(1, GetMetricsObserver(1)->GetEnumCounter(
+                   webrtc::kEnumCounterIceRegatheringReason,
+                   static_cast<int>(
+                       IceRegatheringReason::ICE_RESTART_WHEN_DISCONNECTED)));
+
+  DestroyChannels();
+}
+
+TEST_F(P2PTransportChannelTest,
+       TestIceRegatheringReasonIceRestartWhenConnected) {
+  rtc::ScopedFakeClock clock;
+  ConfigureEndpoints(OPEN, OPEN, kOnlyLocalPorts, kOnlyLocalPorts);
+
+  CreateChannels();
+  EXPECT_TRUE_SIMULATED_WAIT(ep1_ch1()->receiving() && ep1_ch1()->writable() &&
+                                 ep2_ch1()->receiving() &&
+                                 ep2_ch1()->writable(),
+                             kDefaultTimeout, clock);
+
+  ep1_ch1()->SetIceParameters(kIceParams[2]);
+  ep1_ch1()->SetRemoteIceParameters(kIceParams[3]);
+  ep1_ch1()->MaybeStartGathering();
+  EXPECT_EQ(
+      1,
+      GetMetricsObserver(0)->GetEnumCounter(
+          webrtc::kEnumCounterIceRegatheringReason,
+          static_cast<int>(IceRegatheringReason::ICE_RESTART_WHEN_CONNECTED)));
+
+  ep2_ch1()->SetIceParameters(kIceParams[3]);
+  ep2_ch1()->SetRemoteIceParameters(kIceParams[2]);
+  ep2_ch1()->MaybeStartGathering();
+  EXPECT_EQ(
+      1,
+      GetMetricsObserver(1)->GetEnumCounter(
+          webrtc::kEnumCounterIceRegatheringReason,
+          static_cast<int>(IceRegatheringReason::ICE_RESTART_WHEN_CONNECTED)));
+
+  DestroyChannels();
+}
+
+TEST_F(P2PTransportChannelTest,
+       TestIceRegatheringReasonIceRestartWhenConnecting) {
+  rtc::ScopedFakeClock clock;
+  ConfigureEndpoints(OPEN, OPEN, kOnlyLocalPorts, kOnlyLocalPorts);
+
+  // Create the channels without waiting for them to become connected.
+  CreateChannels();
+
+  ep1_ch1()->SetIceParameters(kIceParams[2]);
+  ep1_ch1()->SetRemoteIceParameters(kIceParams[3]);
+  ep1_ch1()->MaybeStartGathering();
+  EXPECT_EQ(
+      1,
+      GetMetricsObserver(0)->GetEnumCounter(
+          webrtc::kEnumCounterIceRegatheringReason,
+          static_cast<int>(IceRegatheringReason::ICE_RESTART_WHEN_CONNECTING)));
+
+  ep2_ch1()->SetIceParameters(kIceParams[3]);
+  ep2_ch1()->SetRemoteIceParameters(kIceParams[2]);
+  ep2_ch1()->MaybeStartGathering();
+  EXPECT_EQ(
+      1,
+      GetMetricsObserver(1)->GetEnumCounter(
+          webrtc::kEnumCounterIceRegatheringReason,
+          static_cast<int>(IceRegatheringReason::ICE_RESTART_WHEN_CONNECTING)));
+
+  DestroyChannels();
+}
+
+// Test the ICE regathering reason where there is a network change on
+// both endpoints and one of them enables continual gathering but the other
+// does not.
+TEST_F(P2PTransportChannelTest,
+       TestIceRegatheringReasonContinualGatheringByNetworkChange) {
+  rtc::ScopedFakeClock clock;
+  ConfigureEndpoints(OPEN, OPEN, kOnlyLocalPorts, kOnlyLocalPorts);
+
+  // ep1 gathers continually but ep2 does not.
+  IceConfig continual_gathering_config =
+      CreateIceConfig(1000, GATHER_CONTINUALLY);
+  IceConfig default_config;
+  CreateChannels(continual_gathering_config, default_config);
+
+  EXPECT_TRUE_SIMULATED_WAIT(ep1_ch1()->receiving() && ep1_ch1()->writable() &&
+                                 ep2_ch1()->receiving() &&
+                                 ep2_ch1()->writable(),
+                             kDefaultTimeout, clock);
+
+  // Add address in ep1 will trigger continual gathering.
+  AddAddress(0, kAlternateAddrs[0]);
+  EXPECT_EQ_SIMULATED_WAIT(
+      1, GetMetricsObserver(0)->GetEnumCounter(
+             webrtc::kEnumCounterIceRegatheringReason,
+             static_cast<int>(
+                 IceRegatheringReason::CONTINUAL_GATHERING_BY_NETWORK_CHANGE)),
+      kDefaultTimeout, clock);
+
+  ep2_ch1()->SetIceParameters(kIceParams[3]);
+  ep2_ch1()->SetRemoteIceParameters(kIceParams[2]);
+  ep2_ch1()->MaybeStartGathering();
+
+  AddAddress(1, kAlternateAddrs[1]);
+  SIMULATED_WAIT(false, kDefaultTimeout, clock);
+  // ep2 has not enabled continual gathering.
+  EXPECT_EQ(
+      0, GetMetricsObserver(1)->GetEnumCounter(
+             webrtc::kEnumCounterIceRegatheringReason,
+             static_cast<int>(
+                 IceRegatheringReason::CONTINUAL_GATHERING_BY_NETWORK_CHANGE)));
+
+  DestroyChannels();
+}
+
+// Test the ICE regathering reason where there is a network failure on
+// both endpoints and one of them enables continual gathering but the other
+// does not.
+TEST_F(P2PTransportChannelTest,
+       TestIceRegatheringReasonContinualGatheringByNetworkFailure) {
+  rtc::ScopedFakeClock clock;
+  ConfigureEndpoints(OPEN, OPEN, kOnlyLocalPorts, kOnlyLocalPorts);
+
+  // ep1 gathers continually but ep2 does not.
+  IceConfig config1 = CreateIceConfig(1000, GATHER_CONTINUALLY);
+  config1.regather_on_failed_networks_interval = rtc::Optional<int>(2000);
+  IceConfig config2;
+  config2.regather_on_failed_networks_interval = rtc::Optional<int>(2000);
+  CreateChannels(config1, config2);
+
+  EXPECT_TRUE_SIMULATED_WAIT(ep1_ch1()->receiving() && ep1_ch1()->writable() &&
+                                 ep2_ch1()->receiving() &&
+                                 ep2_ch1()->writable(),
+                             kDefaultTimeout, clock);
+
+  fw()->AddRule(false, rtc::FP_ANY, rtc::FD_ANY, kPublicAddrs[0]);
+  // Timeout value such that all connections are deleted.
+  const int kNetworkFailureTimeout = 35000;
+  SIMULATED_WAIT(false, kNetworkFailureTimeout, clock);
+  EXPECT_LE(
+      1,
+      GetMetricsObserver(0)->GetEnumCounter(
+          webrtc::kEnumCounterIceRegatheringReason,
+          static_cast<int>(
+              IceRegatheringReason::CONTINUAL_GATHERING_BY_NETWORK_FAILURE)));
+  EXPECT_EQ(
+      0,
+      GetMetricsObserver(1)->GetEnumCounter(
+          webrtc::kEnumCounterIceRegatheringReason,
+          static_cast<int>(
+              IceRegatheringReason::CONTINUAL_GATHERING_BY_NETWORK_FAILURE)));
+
+  DestroyChannels();
+}
+
 // Test that we properly create a connection on a STUN ping from unknown address
 // when the signaling is slow.
 TEST_F(P2PTransportChannelTest, PeerReflexiveCandidateBeforeSignaling) {
   ConfigureEndpoints(OPEN, OPEN, kDefaultPortAllocatorFlags,
                      kDefaultPortAllocatorFlags);
   // Emulate no remote parameters coming in.
   set_remote_ice_parameter_source(FROM_CANDIDATE);
   CreateChannels();
   // Only have remote parameters come in for ep2, not ep1.
   ep2_ch1()->SetRemoteIceParameters(kIceParams[0]);
@@ skipping 2815 matching lines @@
 
   // TCP Relay/Relay is the next.
   VerifyNextPingableConnection(RELAY_PORT_TYPE, RELAY_PORT_TYPE,
                                TCP_PROTOCOL_NAME);
 
   // Finally, Local/Relay will be pinged.
   VerifyNextPingableConnection(LOCAL_PORT_TYPE, RELAY_PORT_TYPE);
 }
 
 }  // namespace cricket {