Add UKM initial_url and session_id fields.

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>
 
 #include "base/bind.h"
 #include "base/feature_list.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
+#include "base/metrics/field_trial_params.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "components/metrics/metrics_log.h"
 #include "components/metrics/metrics_log_uploader.h"
 #include "components/metrics/metrics_service_client.h"
 #include "components/metrics/proto/ukm/entry.pb.h"
 #include "components/metrics/proto/ukm/report.pb.h"
 #include "components/metrics/proto/ukm/source.pb.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 #include "components/ukm/metrics_reporting_scheduler.h"
 #include "components/ukm/persisted_logs_metrics_impl.h"
 #include "components/ukm/ukm_entry.h"
 #include "components/ukm/ukm_entry_builder.h"
 #include "components/ukm/ukm_pref_names.h"
 #include "components/ukm/ukm_source.h"
-#include "components/variations/variations_associated_data.h"
 
 namespace ukm {
 
 namespace {
 
 constexpr char kMimeType[] = "application/vnd.chrome.ukm";
 
 // The UKM server's URL.
 constexpr char kDefaultServerUrl[] = "https://clients4.google.com/ukm";
 
@@ skipping 20 matching lines @@
 // Maximum number of Sources we'll keep in memory before discarding any
 // new ones being added.
 const size_t kMaxSources = 500;
 
 // Maximum number of Entries we'll keep in memory before discarding any
 // new ones being added.
 const size_t kMaxEntries = 5000;
 
 std::string GetServerUrl() {
   std::string server_url =
-      variations::GetVariationParamValueByFeature(kUkmFeature, "ServerUrl");
+      base::GetFieldTrialParamValueByFeature(kUkmFeature, "ServerUrl");
   if (!server_url.empty())
     return server_url;
   return kDefaultServerUrl;
 }
 
+bool ShouldRecordInitialUrl() {
+  return base::GetFieldTrialParamByFeatureAsBool(kUkmFeature,
+                                                 "RecordInitialUrl", false);
+}
+
+bool ShouldRecordSessionId() {
+  return base::GetFieldTrialParamByFeatureAsBool(kUkmFeature, "RecordSessionId",
+                                                 false);
+}
+
 // Generates a new client id and stores it in prefs.
 uint64_t GenerateClientId(PrefService* pref_service) {
   uint64_t client_id = 0;
   while (!client_id)
     client_id = base::RandUint64();
   pref_service->SetInt64(prefs::kUkmClientId, client_id);
+
+  // Also reset the session id counter.
+  pref_service->SetInteger(prefs::kUkmSessionId, 0);
   return client_id;
 }
 
 uint64_t LoadOrGenerateClientId(PrefService* pref_service) {
   uint64_t client_id = pref_service->GetInt64(prefs::kUkmClientId);
   if (!client_id)
     client_id = GenerateClientId(pref_service);
   return client_id;
 }
 
+int32_t LoadSessionId(PrefService* pref_service) {
+  int32_t session_id = pref_service->GetInteger(prefs::kUkmSessionId);
+  ++session_id;  // increment session id, once per session
+  pref_service->SetInteger(prefs::kUkmSessionId, session_id);
+  return session_id;
+}
+
 enum class DroppedDataReason {
   NOT_DROPPED = 0,
   RECORDING_DISABLED = 1,
   MAX_HIT = 2,
   NUM_DROPPED_DATA_REASONS
 };
 
 void RecordDroppedSource(DroppedDataReason reason) {
   UMA_HISTOGRAM_ENUMERATION(
       "UKM.Sources.Dropped", static_cast<int>(reason),
       static_cast<int>(DroppedDataReason::NUM_DROPPED_DATA_REASONS));
 }
 
 void RecordDroppedEntry(DroppedDataReason reason) {
   UMA_HISTOGRAM_ENUMERATION(
       "UKM.Entries.Dropped", static_cast<int>(reason),
       static_cast<int>(DroppedDataReason::NUM_DROPPED_DATA_REASONS));
 }
 
 }  // namespace
 
 const base::Feature kUkmFeature = {"Ukm", base::FEATURE_DISABLED_BY_DEFAULT};
 
 UkmService::UkmService(PrefService* pref_service,
                        metrics::MetricsServiceClient* client)
     : pref_service_(pref_service),
       recording_enabled_(false),
+      client_id_(0),
+      session_id_(0),
       client_(client),
       persisted_logs_(std::unique_ptr<ukm::PersistedLogsMetricsImpl>(
                           new ukm::PersistedLogsMetricsImpl()),
                       pref_service,
                       prefs::kUkmPersistedLogs,
                       kMinPersistedLogs,
                       kMinPersistedBytes,
                       kMaxLogRetransmitSize),
       initialize_started_(false),
       initialize_complete_(false),
@@ skipping 18 matching lines @@
   for (auto& provider : metrics_providers_)
     provider->Init();
 }
 
 UkmService::~UkmService() {
   DisableReporting();
 }
 
 void UkmService::Initialize() {
   DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(!initialize_started_);
   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::EnableRecording() {
@@ skipping 66 matching lines @@
 
 void UkmService::Purge() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "UkmService::Purge";
 
   persisted_logs_.Purge();
   sources_.clear();
   entries_.clear();
 }
 
+// TODO(bmcquade): rename this to something more generic, like
+// ResetClientState. Consider resetting all prefs here.
 void UkmService::ResetClientId() {
   client_id_ = GenerateClientId(pref_service_);
+  session_id_ = LoadSessionId(pref_service_);
 }
 
 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->RegisterIntegerPref(prefs::kUkmSessionId, 0);
   registry->RegisterListPref(prefs::kUkmPersistedLogs);
 }
 
 void UkmService::StartInitTask() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "UkmService::StartInitTask";
   client_id_ = LoadOrGenerateClientId(pref_service_);
+  session_id_ = LoadSessionId(pref_service_);
   client_->InitializeSystemProfileMetrics(base::Bind(
       &UkmService::FinishedInitTask, self_ptr_factory_.GetWeakPtr()));
 }
 
 void UkmService::FinishedInitTask() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "UkmService::FinishedInitTask";
   initialize_complete_ = true;
   scheduler_->InitTaskComplete();
 }
@@ skipping 11 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "UkmService::BuildAndStoreLog";
 
   // Suppress generating a log if we have no new data to include.
   // TODO(zhenw): add a histogram here to debug if this case is hitting a lot.
   if (sources_.empty() && entries_.empty())
     return;
 
   Report report;
   report.set_client_id(client_id_);
+  if (ShouldRecordSessionId())
+    report.set_session_id(session_id_);
 
   for (const auto& source : sources_) {
     Source* proto_source = report.add_sources();
     source->PopulateProto(proto_source);
+    if (!ShouldRecordInitialUrl())
+      proto_source->clear_initial_url();
   }
   for (const auto& entry : entries_) {
     Entry* proto_entry = report.add_entries();
     entry->PopulateProto(proto_entry);
   }
 
   UMA_HISTOGRAM_COUNTS_1000("UKM.Sources.SerializedCount", sources_.size());
   UMA_HISTOGRAM_COUNTS_1000("UKM.Entries.SerializedCount", entries_.size());
   sources_.clear();
   entries_.clear();
@@ skipping 105 matching lines @@
     return;
   }
 
   // Update the pre-existing source if there is any. This happens when the
   // initial URL is different from the committed URL for the same source, e.g.,
   // when there is redirection.
   for (auto& source : sources_) {
     if (source_id != source->id())
       continue;
 
-    source->set_url(url);
+    source->UpdateUrl(url);
     return;
   }
 
   if (sources_.size() >= kMaxSources) {
     RecordDroppedSource(DroppedDataReason::MAX_HIT);
     return;
   }
   std::unique_ptr<UkmSource> source = base::MakeUnique<UkmSource>();
   source->set_id(source_id);
   source->set_url(url);
   sources_.push_back(std::move(source));
 }
 
 void UkmService::AddEntry(std::unique_ptr<UkmEntry> entry) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!recording_enabled_) {
     RecordDroppedEntry(DroppedDataReason::RECORDING_DISABLED);
     return;
   }
   if (entries_.size() >= kMaxEntries) {
     RecordDroppedEntry(DroppedDataReason::MAX_HIT);
     return;
   }
 
   entries_.push_back(std::move(entry));
 }
 
 }  // namespace ukm