Add UMA metrics for ICE regathering reasons.

webrtc/p2p/client/basicportallocator.cc

 /*
  *  Copyright 2004 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 "webrtc/p2p/client/basicportallocator.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
+#include "webrtc/api/peerconnectioninterface.h"
 #include "webrtc/p2p/base/basicpacketsocketfactory.h"
 #include "webrtc/p2p/base/common.h"
 #include "webrtc/p2p/base/port.h"
 #include "webrtc/p2p/base/relayport.h"
 #include "webrtc/p2p/base/stunport.h"
 #include "webrtc/p2p/base/tcpport.h"
 #include "webrtc/p2p/base/turnport.h"
 #include "webrtc/p2p/base/udpport.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/common.h"
@@ skipping 122 matching lines @@
 void BasicPortAllocator::Construct() {
   allow_tcp_listen_ = true;
 }
 
 BasicPortAllocator::~BasicPortAllocator() {
 }
 
 PortAllocatorSession* BasicPortAllocator::CreateSessionInternal(
     const std::string& content_name, int component,
     const std::string& ice_ufrag, const std::string& ice_pwd) {
-  return new BasicPortAllocatorSession(
+  PortAllocatorSession* session = new BasicPortAllocatorSession(
       this, content_name, component, ice_ufrag, ice_pwd);
+  session->SignalIceRegatheringReason.connect(
+      this, &BasicPortAllocator::OnIceRegatheringReason);
+  return session;
 }
 
 void BasicPortAllocator::AddTurnServer(const RelayServerConfig& turn_server) {
   std::vector<RelayServerConfig> new_turn_servers = turn_servers();
   new_turn_servers.push_back(turn_server);
   SetConfiguration(stun_servers(), new_turn_servers, candidate_pool_size(),
                    prune_turn_ports());
 }
 
+void BasicPortAllocator::OnIceRegatheringReason(PortAllocatorSession* session,
+                                                IceRegatheringReason reason) {
+  if (metrics_observer()) {
+    metrics_observer()->IncrementEnumCounter(
+        webrtc::kEnumCounterIceRegatheringReason, static_cast<int>(reason),
+        static_cast<int>(IceRegatheringReason::MAX_VALUE));

[Taylor Brandstetter, 2016/10/03 20:33:35]

Unless I'm mistaken, pooled BasicPortAllocatorSessions will increment the stat
even if they aren't used. Is that intended? It could skew the stats once pooling
becomes available in Chromium.

[honghaiz3, 2016/10/04 01:03:55]

It is true but only under the circumstances where you created sessions that were
not used and then network changed or failed. 
Should a session created in a pool being used right away or very soon?
After second thought, if a session was created in a pool and then a network
change happened and an ICE regathering happened, perhaps it should be counted
anyway because an ICE regathering indeed happened, even though it is not used. 
So it is probably intended. 

[Taylor Brandstetter, 2016/10/04 02:42:32]

If we do count regathering that occurs for pooled sessions, I think it needs to
increment a different stat than for in-use sessions. Because otherwise, we can't
answer a question like: "When regathering occurs for an active connection, how
often is it due to a network change vs. an ICE restart?"

[honghaiz3, 2016/10/05 05:01:53]

Do not count the regathering for pooled sessions for now.  We could add that
later. 

+  }
+}
+
 // BasicPortAllocatorSession
 BasicPortAllocatorSession::BasicPortAllocatorSession(
     BasicPortAllocator* allocator,
     const std::string& content_name,
     int component,
     const std::string& ice_ufrag,
     const std::string& ice_pwd)
     : PortAllocatorSession(content_name,
                            component,
                            ice_ufrag,
@@ skipping 60 matching lines @@
   network_thread_ = rtc::Thread::Current();
   state_ = SessionState::GATHERING;
   if (!socket_factory_) {
     owned_socket_factory_.reset(
         new rtc::BasicPacketSocketFactory(network_thread_));
     socket_factory_ = owned_socket_factory_.get();
   }
 
   network_thread_->Post(RTC_FROM_HERE, this, MSG_CONFIG_START);
 
-  LOG(LS_INFO) << "Pruning turn ports "
+  LOG(LS_INFO) << "Start getting ports with prune_turn_ports "
                << (prune_turn_ports_ ? "enabled" : "disabled");
 }
 
 void BasicPortAllocatorSession::StopGettingPorts() {
   ASSERT(rtc::Thread::Current() == network_thread_);
   ClearGettingPorts();
   // Note: this must be called after ClearGettingPorts because both may set the
   // session state and we should set the state to STOPPED.
   state_ = SessionState::STOPPED;
 }
@@ skipping 28 matching lines @@
                        // If a network does not have any connection, it is
                        // considered failed.
                        return networks_with_connection.find(network->name()) !=
                               networks_with_connection.end();
                      }),
       networks.end());
   return networks;
 }
 
 void BasicPortAllocatorSession::RegatherOnFailedNetworks() {
+  // Do not regather if the allocations has not started, the network manager has
+  // not started, or the session has stopped.
+  if (!allocation_started_ || !network_manager_started_ || IsStopped()) {

[Taylor Brandstetter, 2016/10/03 20:33:35]

This seems separate to adding stats. Could you put it in a different CL, or make
sure this CL's description mentions it?

[honghaiz3, 2016/10/04 01:03:55]

Moved away from this CL. 

+    return;
+  }
+
   // Find the list of networks that have no connection.
   std::vector<rtc::Network*> failed_networks = GetFailedNetworks();
   if (failed_networks.empty()) {
     return;
   }
 
+  LOG(LS_INFO) << "Regather candidates on failed networks";
+
   // Mark a sequence as "network failed" if its network is in the list of failed
   // networks, so that it won't be considered as equivalent when the session
   // regathers ports and candidates.
   for (AllocationSequence* sequence : sequences_) {
     if (!sequence->network_failed() &&
         std::find(failed_networks.begin(), failed_networks.end(),
                   sequence->network()) != failed_networks.end()) {
       sequence->set_network_failed();
     }
   }
   // Remove ports from being used locally and send signaling to remove
   // the candidates on the remote side.
   std::vector<PortData*> ports_to_prune = GetUnprunedPorts(failed_networks);
   if (!ports_to_prune.empty()) {
     LOG(LS_INFO) << "Prune " << ports_to_prune.size()
                  << " ports because their networks failed";
     PrunePortsAndRemoveCandidates(ports_to_prune);
   }
 
-  if (allocation_started_ && network_manager_started_) {
-    DoAllocate();
-  }
+  SignalIceRegatheringReason(
+      this, IceRegatheringReason::CONTINUAL_GATHERING_BY_NETWORK_FAILURE);
+
+  DoAllocate();
 }
 
 std::vector<PortInterface*> BasicPortAllocatorSession::ReadyPorts() const {
   std::vector<PortInterface*> ret;
   for (const PortData& data : ports_) {
     if (data.ready()) {
       ret.push_back(data.port());
     }
   }
   return ret;
@@ skipping 157 matching lines @@
     MaybeSignalCandidatesAllocationDone();
   }
 }
 
 void BasicPortAllocatorSession::AllocatePorts() {
   ASSERT(rtc::Thread::Current() == network_thread_);
   network_thread_->Post(RTC_FROM_HERE, this, MSG_ALLOCATE);
 }
 
 void BasicPortAllocatorSession::OnAllocate() {
-  if (network_manager_started_)
+  if (network_manager_started_ && !IsStopped())

[Taylor Brandstetter, 2016/10/03 20:33:35]

Same here.

[honghaiz3, 2016/10/04 01:03:55]

This is not a behavior change. 
I just moved the check of IsStopped from the DoAllocate to the outside of the
call. 
I need this change in this CL because I do not want to signal an
ICERegatheringReason when the session has stopped. 

[Taylor Brandstetter, 2016/10/04 02:42:32]

Acknowledged.

[honghaiz3, 2016/10/05 05:01:53]

Acknowledged.

     DoAllocate();
 
   allocation_started_ = true;
 }
 
 std::vector<rtc::Network*> BasicPortAllocatorSession::GetNetworks() {
   std::vector<rtc::Network*> networks;
   rtc::NetworkManager* network_manager = allocator_->network_manager();
   ASSERT(network_manager != nullptr);
   // If the network permission state is BLOCKED, we just act as if the flag has
@@ skipping 31 matching lines @@
                    networks.end());
   }
   return networks;
 }
 
 // For each network, see if we have a sequence that covers it already.  If not,
 // create a new sequence to create the appropriate ports.
 void BasicPortAllocatorSession::DoAllocate() {
   bool done_signal_needed = false;
   std::vector<rtc::Network*> networks = GetNetworks();
-
-  if (IsStopped()) {
-    return;
-  }
   if (networks.empty()) {
     LOG(LS_WARNING) << "Machine has no networks; no ports will be allocated";
     done_signal_needed = true;
   } else {
     LOG(LS_INFO) << "Allocate ports on "<< networks.size() << " networks";
     PortConfiguration* config = configs_.empty() ? nullptr : configs_.back();
     for (uint32_t i = 0; i < networks.size(); ++i) {
       uint32_t sequence_flags = flags();
       if ((sequence_flags & DISABLE_ALL_PHASES) == DISABLE_ALL_PHASES) {
         // If all the ports are disabled we should just fire the allocation
@@ skipping 50 matching lines @@
       failed_networks.push_back(sequence->network());
     }
   }
   std::vector<PortData*> ports_to_prune = GetUnprunedPorts(failed_networks);
   if (!ports_to_prune.empty()) {
     LOG(LS_INFO) << "Prune " << ports_to_prune.size()
                  << " ports because their networks were gone";
     PrunePortsAndRemoveCandidates(ports_to_prune);
   }
 
+  if (allocation_started_ && !IsStopped()) {
+    if (network_manager_started_) {
+      // If the network manager has started, it must be a regathering.
+      SignalIceRegatheringReason(
+          this, IceRegatheringReason::CONTINUAL_GATHERING_BY_NETWORK_CHANGE);
+    }
+    DoAllocate();
+  }
+
   if (!network_manager_started_) {
-    LOG(LS_INFO) << "Network manager is started";
+    LOG(LS_INFO) << "Network manager has started";
     network_manager_started_ = true;
   }
-  if (allocation_started_)
-    DoAllocate();
 }
 
 void BasicPortAllocatorSession::DisableEquivalentPhases(
     rtc::Network* network,
     PortConfiguration* config,
     uint32_t* flags) {
   for (uint32_t i = 0; i < sequences_.size() &&
                            (*flags & DISABLE_ALL_PHASES) != DISABLE_ALL_PHASES;
        ++i) {
     sequences_[i]->DisableEquivalentPhases(network, config, flags);
@@ skipping 837 matching lines @@
   ServerAddresses servers;
   for (size_t i = 0; i < relays.size(); ++i) {
     if (relays[i].type == turn_type && SupportsProtocol(relays[i], type)) {
       servers.insert(relays[i].ports.front().address);
     }
   }
   return servers;
 }
 
 }  // namespace cricket