UKM Sync Observer

components/ukm/ukm_service_unittest.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 <string>
 #include <utility>
 
 #include "base/test/test_simple_task_runner.h"
@@ skipping 23 matching lines @@
     prefs_.ClearPref(prefs::kUkmPersistedLogs);
   }
 
   int GetPersistedLogCount() {
     const base::ListValue* list_value =
         prefs_.GetList(prefs::kUkmPersistedLogs);
     return list_value->GetSize();
   }
 
   Report GetPersistedReport() {
+    EXPECT_GE(GetPersistedLogCount(), 1);
     metrics::PersistedLogs result_persisted_logs(
         base::MakeUnique<ukm::PersistedLogsMetricsImpl>(), &prefs_,
         prefs::kUkmPersistedLogs,
         3,     // log count limit
         1000,  // byte limit
         0);
 
     result_persisted_logs.DeserializeLogs();
     result_persisted_logs.StageLog();
 
     std::string uncompressed_log_data;
     EXPECT_TRUE(compression::GzipUncompress(result_persisted_logs.staged_log(),
                                             &uncompressed_log_data));
 
     Report report;
     EXPECT_TRUE(report.ParseFromString(uncompressed_log_data));
     return report;
   }
 
+  std::unique_ptr<UkmSource> MakeSource(std::string url, int paint_msec) {
+    auto source = base::MakeUnique<UkmSource>();
+    source->set_committed_url(GURL(url));
+    source->set_first_contentful_paint(
+        base::TimeDelta::FromMilliseconds(paint_msec));
+    return source;
+  }
+
  protected:
   TestingPrefServiceSimple prefs_;
   metrics::TestMetricsServiceClient client_;
 
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   base::ThreadTaskRunnerHandle task_runner_handle_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UkmServiceTest);
 };
 
 }  // namespace
 
 TEST_F(UkmServiceTest, EnableDisableSchedule) {
   UkmService service(&prefs_, &client_);
   EXPECT_FALSE(task_runner_->HasPendingTask());
   service.Initialize();
   EXPECT_TRUE(task_runner_->HasPendingTask());
   // Allow initialization to complete.
   task_runner_->RunUntilIdle();
+  service.EnableRecording();
   service.EnableReporting();
   EXPECT_TRUE(task_runner_->HasPendingTask());
   service.DisableReporting();
   task_runner_->RunPendingTasks();
   EXPECT_FALSE(task_runner_->HasPendingTask());
 }
 
 TEST_F(UkmServiceTest, PersistAndPurge) {
   UkmService service(&prefs_, &client_);
   EXPECT_EQ(GetPersistedLogCount(), 0);
   service.Initialize();
   task_runner_->RunUntilIdle();
+  service.EnableRecording();
   service.EnableReporting();
+  service.RecordSource(MakeSource("https://google.com", 300));
   // Should init, generate a log, and start an upload.
   task_runner_->RunPendingTasks();
   EXPECT_TRUE(client_.uploader()->is_uploading());
   // Flushes the generated log to disk and generates a new one.
+  service.RecordSource(MakeSource("https://google.com", 300));
   service.Flush();
   EXPECT_EQ(GetPersistedLogCount(), 2);
   service.Purge();
   EXPECT_EQ(GetPersistedLogCount(), 0);
 }
 
 TEST_F(UkmServiceTest, SourceSerialization) {
   UkmService service(&prefs_, &client_);
   EXPECT_EQ(GetPersistedLogCount(), 0);
   service.Initialize();
   task_runner_->RunUntilIdle();
+  service.EnableRecording();
   service.EnableReporting();
 
-  std::unique_ptr<UkmSource> source = base::WrapUnique(new UkmSource());
-  source->set_committed_url(GURL("https://google.com"));
-  source->set_first_contentful_paint(base::TimeDelta::FromMilliseconds(300));
-
-  service.RecordSource(std::move(source));
+  service.RecordSource(MakeSource("https://google.com", 300));
 
   service.Flush();
   EXPECT_EQ(GetPersistedLogCount(), 1);
 
   Report proto_report = GetPersistedReport();
   EXPECT_EQ(1, proto_report.sources_size());
   const Source& proto_source = proto_report.sources(0);
 
   EXPECT_EQ(GURL("https://google.com").spec(), proto_source.url());
   EXPECT_EQ(300, proto_source.first_contentful_paint_msec());
 }
 
 TEST_F(UkmServiceTest, MetricsProviderTest) {
   UkmService service(&prefs_, &client_);
 
   metrics::TestMetricsProvider* provider = new metrics::TestMetricsProvider();
   service.RegisterMetricsProvider(
       std::unique_ptr<metrics::MetricsProvider>(provider));
 
   service.Initialize();
 
   // Providers have not supplied system profile information yet.
   EXPECT_FALSE(provider->provide_system_profile_metrics_called());
 
   task_runner_->RunUntilIdle();
+  service.EnableRecording();
   service.EnableReporting();
 
-  service.RecordSource(base::WrapUnique(new UkmSource()));
+  service.RecordSource(MakeSource("https://google.com", 300));
   service.Flush();
   EXPECT_EQ(GetPersistedLogCount(), 1);
 
   Report proto_report = GetPersistedReport();
   EXPECT_EQ(1, proto_report.sources_size());
 
   // Providers have now supplied system profile information.
   EXPECT_TRUE(provider->provide_system_profile_metrics_called());
 }
 
 }  // namespace ukm