Add Feature params for UKM Service to control thresholds on sources and 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>
 
@@ skipping 20 matching lines @@
 #include "components/ukm/ukm_entry_builder.h"
 #include "components/ukm/ukm_pref_names.h"
 #include "components/ukm/ukm_source.h"
 
 namespace ukm {
 
 namespace {
 
 constexpr char kMimeType[] = "application/vnd.chrome.ukm";
 
-// The UKM server's URL.
-constexpr char kDefaultServerUrl[] = "https://clients4.google.com/ukm";
-
 // The delay, in seconds, after starting recording before doing expensive
 // initialization work.
 constexpr int kInitializationDelaySeconds = 5;
 
 // The number of UKM logs that will be stored in PersistedLogs before logs
 // start being dropped.
 constexpr int kMinPersistedLogs = 8;
 
 // The number of bytes UKM logs that will be stored in PersistedLogs before
 // logs start being dropped.
 // This ensures that a reasonable amount of history will be stored even if there
 // is a long series of very small logs.
 constexpr int kMinPersistedBytes = 300000;
 
 // If an upload fails, and the transmission was over this byte count, then we
 // will discard the log, and not try to retransmit it.  We also don't persist
 // the log to the prefs for transmission during the next chrome session if this
 // limit is exceeded.
 constexpr size_t kMaxLogRetransmitSize = 100 * 1024;
 
-// 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;
-
+// 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 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.
+size_t GetMaxEntries() {
+  constexpr size_t kDefaultMaxEntries = 5000;
+  return static_cast<size_t>(base::GetFieldTrialParamByFeatureAsInt(
+      kUkmFeature, "MaxEntries", kDefaultMaxEntries));
+}
+
+// True if we should record the initial_url field of the UKM Source proto.
 bool ShouldRecordInitialUrl() {
   return base::GetFieldTrialParamByFeatureAsBool(kUkmFeature,
                                                  "RecordInitialUrl", false);
 }
 
+// True if we should record session ids in the UKM Report proto.
 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();
@@ skipping 316 matching lines @@
                              persisted_logs_.has_unsent_logs());
 }
 
 void UkmService::RecordSource(std::unique_ptr<UkmSource> source) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!recording_enabled_) {
     RecordDroppedSource(DroppedDataReason::RECORDING_DISABLED);
     return;
   }
-  if (sources_.size() >= kMaxSources) {
+  if (sources_.size() >= GetMaxSources()) {
     RecordDroppedSource(DroppedDataReason::MAX_HIT);
     return;
   }
 
   sources_.push_back(std::move(source));
 }
 
 // static
 int32_t UkmService::GetNewSourceID() {
   static int32_t next_source_id = 0;
@@ skipping 20 matching lines @@
   // 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->UpdateUrl(url);
     return;
   }
 
-  if (sources_.size() >= kMaxSources) {
+  if (sources_.size() >= GetMaxSources()) {
     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) {
+  if (entries_.size() >= GetMaxEntries()) {
     RecordDroppedEntry(DroppedDataReason::MAX_HIT);
     return;
   }
 
   entries_.push_back(std::move(entry));
 }
 
 }  // namespace ukm