Create Field Trial param for whitelisting UKM Entries.

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/metrics/metrics_hashes.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/strings/string_split.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"
@@ skipping 32 matching lines @@
 // Gets the UKM Server URL.
 std::string GetServerUrl() {
   constexpr char kDefaultServerUrl[] = "https://clients4.google.com/ukm";
   std::string server_url =
       base::GetFieldTrialParamValueByFeature(kUkmFeature, "ServerUrl");
   if (!server_url.empty())
     return server_url;
   return kDefaultServerUrl;
 }
 
+// Gets the list of whitelisted Entries as string. Format is a comma seperated
+// list of Entry names (as strings).
+std::string GetWhitelistEntries() {
+  return base::GetFieldTrialParamValueByFeature(kUkmFeature,
+                                                "WhitelistEntries");
+}
+
 // Gets the maximum number of Sources we'll keep in memory before discarding any
 // new ones being added.
 size_t GetMaxSources() {
   constexpr size_t kDefaultMaxSources = 500;
   return static_cast<size_t>(base::GetFieldTrialParamByFeatureAsInt(
       kUkmFeature, "MaxSources", kDefaultMaxSources));
 }
 
 // Gets the maximum number of Entries we'll keep in memory before discarding any
 // new ones being added.
@@ skipping 38 matching lines @@
   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,
+  NOT_WHITELISTED = 3,
   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) {
@@ skipping 35 matching lines @@
   // 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();
+
+  StoreWhitelistedEntries();
 }
 
 UkmService::~UkmService() {
   DisableReporting();
 }
 
 void UkmService::Initialize() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!initialize_started_);
   DVLOG(1) << "UkmService::Initialize";
@@ skipping 276 matching lines @@
 
   if (!recording_enabled_) {
     RecordDroppedEntry(DroppedDataReason::RECORDING_DISABLED);
     return;
   }
   if (entries_.size() >= GetMaxEntries()) {
     RecordDroppedEntry(DroppedDataReason::MAX_HIT);
     return;
   }
 
+  if (!whitelisted_entry_hashes_.empty() &&
+      !base::ContainsKey(whitelisted_entry_hashes_, entry->event_hash())) {
+    RecordDroppedEntry(DroppedDataReason::NOT_WHITELISTED);
+    return;
+  }
+
   entries_.push_back(std::move(entry));
 }
 
+void UkmService::StoreWhitelistedEntries() {
+  const auto entries =
+      base::SplitString(GetWhitelistEntries(), ",", base::TRIM_WHITESPACE,
+                        base::SPLIT_WANT_NONEMPTY);
+  for (const auto& entry_string : entries) {
+    whitelisted_entry_hashes_.insert(base::HashMetricName(entry_string));
+  }
+}
+
 }  // namespace ukm