Add network information to UKM

components/ukm/ukm_service.cc

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/ukm/ukm_service.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 
@@ skipping 96 matching lines @@
 
   base::Closure rotate_callback =
       base::Bind(&UkmService::RotateLog, self_ptr_factory_.GetWeakPtr());
   // MetricsServiceClient outlives UkmService, and
   // MetricsReportingScheduler is tied to the lifetime of |this|.
   const base::Callback<base::TimeDelta(void)>& get_upload_interval_callback =
       base::Bind(&metrics::MetricsServiceClient::GetStandardUploadInterval,
                  base::Unretained(client_));
   scheduler_.reset(new ukm::MetricsReportingScheduler(
       rotate_callback, get_upload_interval_callback));
+
+  for (auto& provider : metrics_providers_)
+    provider->Init();
 }
 
 UkmService::~UkmService() {
   DisableReporting();
 }
 
 void UkmService::Initialize() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "UkmService::Initialize";
   initialize_started_ = true;
 
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&UkmService::StartInitTask, self_ptr_factory_.GetWeakPtr()),
       base::TimeDelta::FromSeconds(kInitializationDelaySeconds));
 }
 
 void UkmService::EnableReporting() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "UkmService::EnableReporting";
+
+  for (auto& provider : metrics_providers_)
+    provider->OnRecordingEnabled();
+
   if (!initialize_started_)
     Initialize();
   scheduler_->Start();
 }
 
 void UkmService::DisableReporting() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "UkmService::DisableReporting";
+
+  for (auto& provider : metrics_providers_)
+    provider->OnRecordingDisabled();
+
   scheduler_->Stop();
   Flush();
 }
 
 void UkmService::Flush() {
   if (initialize_complete_)
     BuildAndStoreLog();
   persisted_logs_.SerializeLogs();
 }
 
 void UkmService::Purge() {
   DVLOG(1) << "UkmService::Purge";
   persisted_logs_.Purge();
   sources_.clear();
 }
 
+void UkmService::RegisterMetricsProvider(
+    std::unique_ptr<metrics::MetricsProvider> provider) {
+  metrics_providers_.push_back(std::move(provider));
+}
+
 // static
 void UkmService::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterInt64Pref(prefs::kUkmClientId, 0);
   registry->RegisterListPref(prefs::kUkmPersistedLogs);
 }
 
 void UkmService::StartInitTask() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "UkmService::StartInitTask";
   client_id_ = LoadOrGenerateClientId(pref_service_);
@@ skipping 26 matching lines @@
 
   for (const auto& source : sources_) {
     Source* proto_source = report.add_sources();
     source->PopulateProto(proto_source);
   }
   UMA_HISTOGRAM_COUNTS_1000("UKM.Sources.SerializedCount", sources_.size());
   sources_.clear();
 
   metrics::MetricsLog::RecordCoreSystemProfile(client_,
                                                report.mutable_system_profile());
-  // TODO(rkaplow): Populate network information.
+
+  for (auto& provider : metrics_providers_) {
+    provider->ProvideSystemProfileMetrics(report.mutable_system_profile());
+  }
+
   std::string serialized_log;
   report.SerializeToString(&serialized_log);
   persisted_logs_.StoreLog(serialized_log);
 }
 
 void UkmService::StartScheduledUpload() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!log_upload_in_progress_);
   if (!persisted_logs_.has_staged_log())
     persisted_logs_.StageLog();
@@ skipping 46 matching lines @@
 void UkmService::RecordSource(std::unique_ptr<UkmSource> source) {
   if (sources_.size() >= kMaxSources) {
     UMA_HISTOGRAM_BOOLEAN("UKM.Sources.MaxSourcesHit", true);
     return;
   }
 
   sources_.push_back(std::move(source));
 }
 
 }  // namespace ukm