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 45 matching lines @@
 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;
+const size_t kDefaultMaxSources = 500;
 
 // Maximum number of Entries we'll keep in memory before discarding any
 // new ones being added.
-const size_t kMaxEntries = 5000;
+const size_t kDefaultMaxEntries = 5000;
 
 std::string GetServerUrl() {
   std::string server_url =
       base::GetFieldTrialParamValueByFeature(kUkmFeature, "ServerUrl");
   if (!server_url.empty())
     return server_url;
   return kDefaultServerUrl;
 }
 
+size_t GetMaxSources() {

[Alexei Svitkine (slow), 2017/03/02 23:13:42]

Nit: Can you add comments to these?

+  return static_cast<size_t>(base::GetFieldTrialParamByFeatureAsInt(
+      kUkmFeature, "MaxSources", kDefaultMaxSources));
+}
+
+size_t GetMaxEntries() {
+  return static_cast<size_t>(base::GetFieldTrialParamByFeatureAsInt(
+      kUkmFeature, "MaxEntries", kDefaultMaxEntries));
+}
+
 bool ShouldRecordInitialUrl() {
   return base::GetFieldTrialParamByFeatureAsBool(kUkmFeature,
                                                  "RecordInitialUrl", false);
 }
 
 bool ShouldRecordSessionId() {
   return base::GetFieldTrialParamByFeatureAsBool(kUkmFeature, "RecordSessionId",
                                                  false);
 }
 
@@ skipping 321 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