Initial UKMPageLoadMetricsObserver

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/feature_list.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.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_uploader.h"
 #include "components/metrics/metrics_service_client.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_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 11 matching lines @@
 // 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 around before dropping new ones.
+const size_t kMaxSourcesLength = 100;
+
 std::string GetServerUrl() {
   std::string server_url =
       variations::GetVariationParamValueByFeature(kUkmFeature, "ServerUrl");
   if (!server_url.empty())
     return server_url;
   return kDefaultServerUrl;
 }
 
 uint64_t LoadOrGenerateClientId(PrefService* pref_service) {
   uint64_t client_id = pref_service->GetInt64(prefs::kUkmClientId);
@@ skipping 73 matching lines @@
 
 void UkmService::Flush() {
   if (initialize_complete_)
     BuildAndStoreLog();
   persisted_logs_.SerializeLogs();
 }
 
 void UkmService::Purge() {
   DVLOG(1) << "UkmService::Purge";
   persisted_logs_.Purge();
-  // TODO(oystein): Delete any stored sources.
+  sources_.clear();
 }
 
 // static
 void UkmService::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterInt64Pref(prefs::kUkmClientId, 0);
   registry->RegisterListPref(prefs::kUkmPersistedLogs);
 }
 
 void UkmService::StartInitTask() {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 19 matching lines @@
   }
   StartScheduledUpload();
 }
 
 void UkmService::BuildAndStoreLog() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "UkmService::BuildAndStoreLog";
   Report report;
   report.set_client_id(client_id_);
   // TODO(holte): Populate system_profile.
-  // TODO(oystein): Populate sources.
+  for (auto& source : sources_) {
+    Source* proto_source = report.add_sources();
+    source->PopulateProto(proto_source);
+  }
+  sources_.clear();
+
   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 36 matching lines @@
     // Store the updated list to disk now that the removed log is uploaded.
     persisted_logs_.SerializeLogs();
   }
 
   // Error 400 indicates a problem with the log, not with the server, so
   // don't consider that a sign that the server is in trouble.
   bool server_is_healthy = upload_succeeded || response_code == 400;
   scheduler_->UploadFinished(server_is_healthy, !persisted_logs_.empty());
 }
 
+void UkmService::RecordSource(std::unique_ptr<UkmSource> source) {
+  if (sources_.size() >= kMaxSourcesLength)
+    return;
+
+  sources_.push_back(std::move(source));
+}
+
 }  // namespace ukm