Ensure that PC usage is recorded if a PC is alive for 60 seconds.

Bug: chromium:718508
Change-Id: Id2cbcb370b56cb8a6a6c821e0f89c51089cc8e6b
Reviewed-on: https://webrtc-review.googlesource.com/83140
Commit-Queue: Harald Alvestrand <hta@webrtc.org>
Reviewed-by: Henrik Boström <hbos@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#23723}

pc/BUILD.gn

@@ -435,6 +435,7 @@ if (rtc_include_tests) {
       "peerconnection_bundle_unittest.cc",
       "peerconnection_crypto_unittest.cc",
       "peerconnection_datachannel_unittest.cc",
+      "peerconnection_histogram_unittest.cc",
       "peerconnection_ice_unittest.cc",
       "peerconnection_integrationtest.cc",
       "peerconnection_jsep_unittest.cc",

pc/peerconnection.cc

@@ -106,8 +106,11 @@ enum {
   MSG_CREATE_SESSIONDESCRIPTION_FAILED,
   MSG_GETSTATS,
   MSG_FREE_DATACHANNELS,
+  MSG_REPORT_USAGE_PATTERN,
 };
 
+static const int REPORT_USAGE_PATTERN_DELAY_MS = 60000;
+
 struct SetSessionDescriptionMsg : public rtc::MessageData {
   explicit SetSessionDescriptionMsg(
       webrtc::SetSessionDescriptionObserver* observer)
@@ -1037,6 +1040,10 @@ bool PeerConnection::Initialize(
         RtpTransceiverProxyWithInternal<RtpTransceiver>::Create(
             signaling_thread(), new RtpTransceiver(cricket::MEDIA_TYPE_VIDEO)));
   }
+  signaling_thread()->PostDelayed(
+      RTC_FROM_HERE,
+      return_histogram_very_quickly_ ? 0 : REPORT_USAGE_PATTERN_DELAY_MS, this,
+      MSG_REPORT_USAGE_PATTERN, nullptr);
   return true;
 }
 
@@ -3300,6 +3307,10 @@ void PeerConnection::OnMessage(rtc::Message* msg) {
       sctp_data_channels_to_free_.clear();
       break;
     }
+    case MSG_REPORT_USAGE_PATTERN: {
+      ReportUsagePattern();
+      break;
+    }
     default:
       RTC_NOTREACHED() << "Not implemented";
       break;

pc/peerconnection.h

@@ -265,6 +265,10 @@ class PeerConnection : public PeerConnectionInternal,
   bool NeedsIceRestart(const std::string& content_name) const override;
   bool GetSslRole(const std::string& content_name, rtc::SSLRole* role) override;
 
+  void ReturnHistogramVeryQuicklyForTesting() {
+    return_histogram_very_quickly_ = true;
+  }
+
  protected:
   ~PeerConnection() override;
 
@@ -1017,6 +1021,7 @@ class PeerConnection : public PeerConnectionInternal,
   cricket::VideoOptions video_options_;
 
   int usage_event_accumulator_ = 0;
+  bool return_histogram_very_quickly_ = false;
 };
 
 }  // namespace webrtc

pc/peerconnection_histogram_unittest.cc

@@ -0,0 +1,145 @@
+/*
+ *  Copyright 2017 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 <tuple>
+
+#include "api/fakemetricsobserver.h"
+#include "api/peerconnectionproxy.h"
+#include "media/base/fakemediaengine.h"
+#include "pc/mediasession.h"
+#include "pc/peerconnection.h"
+#include "pc/peerconnectionfactory.h"
+#include "pc/peerconnectionwrapper.h"
+#include "pc/sdputils.h"
+#ifdef WEBRTC_ANDROID
+#include "pc/test/androidtestinitializer.h"
+#endif
+#include "pc/test/fakesctptransport.h"
+#include "rtc_base/gunit.h"
+#include "rtc_base/ptr_util.h"
+#include "rtc_base/virtualsocketserver.h"
+
+namespace webrtc {
+
+using RTCConfiguration = PeerConnectionInterface::RTCConfiguration;
+using RTCOfferAnswerOptions = PeerConnectionInterface::RTCOfferAnswerOptions;
+using ::testing::Values;
+
+static constexpr int kDefaultTimeout = 10000;
+
+int MakeUsageFingerprint(std::set<PeerConnection::UsageEvent> events) {
+  int signature = 0;
+  for (const auto it : events) {
+    signature |= static_cast<int>(it);
+  }
+  return signature;
+}
+
+class PeerConnectionFactoryForUsageHistogramTest
+    : public rtc::RefCountedObject<PeerConnectionFactory> {
+ public:
+  PeerConnectionFactoryForUsageHistogramTest()
+      : rtc::RefCountedObject<PeerConnectionFactory>(
+            rtc::Thread::Current(),
+            rtc::Thread::Current(),
+            rtc::Thread::Current(),
+            rtc::MakeUnique<cricket::FakeMediaEngine>(),
+            CreateCallFactory(),
+            nullptr) {}
+
+  void ActionsBeforeInitializeForTesting(PeerConnectionInterface* pc) override {
+    PeerConnection* internal_pc = static_cast<PeerConnection*>(pc);
+    if (return_histogram_very_quickly_) {
+      internal_pc->ReturnHistogramVeryQuicklyForTesting();
+    }
+  }
+
+  void ReturnHistogramVeryQuickly() { return_histogram_very_quickly_ = true; }
+
+ private:
+  bool return_histogram_very_quickly_;
+};
+
+class PeerConnectionWrapperForUsageHistogramTest
+    : public PeerConnectionWrapper {
+ public:
+  using PeerConnectionWrapper::PeerConnectionWrapper;
+
+  PeerConnection* GetInternalPeerConnection() {
+    auto* pci =
+        static_cast<PeerConnectionProxyWithInternal<PeerConnectionInterface>*>(
+            pc());
+    return static_cast<PeerConnection*>(pci->internal());
+  }
+};
+
+class PeerConnectionUsageHistogramTest : public ::testing::Test {
+ protected:
+  typedef std::unique_ptr<PeerConnectionWrapperForUsageHistogramTest>
+      WrapperPtr;
+
+  PeerConnectionUsageHistogramTest()
+      : vss_(new rtc::VirtualSocketServer()), main_(vss_.get()) {
+#ifdef WEBRTC_ANDROID
+    InitializeAndroidObjects();
+#endif
+  }
+
+  WrapperPtr CreatePeerConnection() {
+    return CreatePeerConnection(
+        RTCConfiguration(), PeerConnectionFactoryInterface::Options(), false);
+  }
+
+  WrapperPtr CreatePeerConnectionWithImmediateReport() {
+    return CreatePeerConnection(
+        RTCConfiguration(), PeerConnectionFactoryInterface::Options(), true);
+  }
+
+  WrapperPtr CreatePeerConnection(
+      const RTCConfiguration& config,
+      const PeerConnectionFactoryInterface::Options factory_options,
+      bool immediate_report) {
+    rtc::scoped_refptr<PeerConnectionFactoryForUsageHistogramTest> pc_factory(
+        new PeerConnectionFactoryForUsageHistogramTest());
+    pc_factory->SetOptions(factory_options);
+    RTC_CHECK(pc_factory->Initialize());
+    if (immediate_report) {
+      pc_factory->ReturnHistogramVeryQuickly();
+    }
+    auto observer = rtc::MakeUnique<MockPeerConnectionObserver>();
+    auto pc = pc_factory->CreatePeerConnection(config, nullptr, nullptr,
+                                               observer.get());
+    if (!pc) {
+      return nullptr;
+    }
+
+    auto wrapper = rtc::MakeUnique<PeerConnectionWrapperForUsageHistogramTest>(
+        pc_factory, pc, std::move(observer));
+    return wrapper;
+  }
+
+  std::unique_ptr<rtc::VirtualSocketServer> vss_;
+  rtc::AutoSocketServerThread main_;
+};
+
+TEST_F(PeerConnectionUsageHistogramTest, UsageFingerprintHistogramFromTimeout) {
+  auto pc = CreatePeerConnectionWithImmediateReport();
+
+  // Register UMA observer before signaling begins.
+  rtc::scoped_refptr<webrtc::FakeMetricsObserver> caller_observer =
+      new rtc::RefCountedObject<webrtc::FakeMetricsObserver>();
+  pc->GetInternalPeerConnection()->RegisterUMAObserver(caller_observer);
+  int expected_fingerprint = MakeUsageFingerprint({});
+  ASSERT_TRUE_WAIT(caller_observer->ExpectOnlySingleEnumCount(
+                       webrtc::kEnumCounterUsagePattern, expected_fingerprint),
+                   kDefaultTimeout);
+}
+
+}  // namespace webrtc

pc/peerconnectionfactory.cc

@@ -338,7 +338,7 @@ PeerConnectionFactory::CreatePeerConnection(
   rtc::scoped_refptr<PeerConnection> pc(
       new rtc::RefCountedObject<PeerConnection>(this, std::move(event_log),
                                                 std::move(call)));
-
+  ActionsBeforeInitializeForTesting(pc);
   if (!pc->Initialize(configuration, std::move(dependencies))) {
     return nullptr;
   }

pc/peerconnectionfactory.h

@@ -122,6 +122,10 @@ class PeerConnectionFactory : public PeerConnectionFactoryInterface {
   explicit PeerConnectionFactory(
       PeerConnectionFactoryDependencies dependencies);
 
+  // Hook to let testing framework insert actions between
+  // "new RTCPeerConnection" and "pc.Initialize"
+  virtual void ActionsBeforeInitializeForTesting(PeerConnectionInterface*) {}
+
   virtual ~PeerConnectionFactory();
 
  private: