Re-remove deprecated UKM test APIs.

Bug: 761524
Change-Id: Ia9f024dc01732814a8b8eaf7a5284f99e899e418
Reviewed-on: https://chromium-review.googlesource.com/976948
Commit-Queue: Steven Holte <holte@chromium.org>
Reviewed-by: Bryan McQuade <bmcquade@chromium.org>
Reviewed-by: Mitsuru Oshima <oshima@chromium.org>
Reviewed-by: Siddhartha S <ssid@chromium.org>
Cr-Commit-Position: refs/heads/master@{#545642}

chrome/browser/chromeos/power/ml/user_activity_manager_unittest.cc

@@ -28,6 +28,7 @@
 #include "chromeos/dbus/power_manager/power_supply_properties.pb.h"
 #include "chromeos/dbus/power_manager_client.h"
 #include "components/session_manager/session_manager_types.h"
+#include "components/ukm/content/source_url_recorder.h"
 #include "components/ukm/test_ukm_recorder.h"
 #include "components/ukm/ukm_source.h"
 #include "content/public/browser/web_contents.h"
@@ -181,10 +182,10 @@ class UserActivityManagerTest : public ChromeRenderViewHostTestHarness {
   // If |mime_type| is an empty string, the content has a default text type.
   // TODO(jiameng): there doesn't seem to be a way to set form entry (via
   // page importance signal). Check if there's some other way to set it.
-  void CreateTestWebContents(TabStripModel* const tab_strip_model,
-                             const GURL& url,
-                             bool is_active,
-                             const std::string& mime_type = "") {
+  ukm::SourceId CreateTestWebContents(TabStripModel* const tab_strip_model,
+                                      const GURL& url,
+                                      bool is_active,
+                                      const std::string& mime_type = "") {
     DCHECK(tab_strip_model);
     DCHECK(!url.is_empty());
     content::WebContents* contents =
@@ -196,12 +197,7 @@ class UserActivityManagerTest : public ChromeRenderViewHostTestHarness {
       WebContentsTester::For(contents)->SetMainFrameMimeType(mime_type);
 
     WebContentsTester::For(contents)->TestSetIsLoading(false);
-  }
-
-  ukm::SourceId GetSourceIdForUrl(const GURL& url) {
-    const ukm::UkmSource* source = ukm_recorder_.GetSourceForUrl(url);
-    DCHECK(source);
-    return source->id();
+    return ukm::GetSourceIdForWebContentsDocument(contents);
   }
 
   void CheckTabsProperties(
@@ -656,13 +652,12 @@ TEST_F(UserActivityManagerTest, BasicTabs) {
       CreateTestBrowser(true /* is_visible */, true /* is_focused */);
   BrowserList::GetInstance()->SetLastActive(browser.get());
   TabStripModel* tab_strip_model = browser->tab_strip_model();
-  CreateTestWebContents(tab_strip_model, url1_, true /* is_active */,
-                        "application/pdf");
+  const ukm::SourceId source_id1 = CreateTestWebContents(
+      tab_strip_model, url1_, true /* is_active */, "application/pdf");
   SiteEngagementService::Get(profile())->ResetBaseScoreForURL(url1_, 95);
-  const ukm::SourceId source_id1 = GetSourceIdForUrl(url1_);
 
-  CreateTestWebContents(tab_strip_model, url2_, false /* is_active */);
-  const ukm::SourceId source_id2 = GetSourceIdForUrl(url2_);
+  const ukm::SourceId source_id2 =
+      CreateTestWebContents(tab_strip_model, url2_, false /* is_active */);
 
   UpdateOpenTabsURLs();
 
@@ -709,18 +704,18 @@ TEST_F(UserActivityManagerTest, MultiBrowsersAndTabs) {
   BrowserList::GetInstance()->SetLastActive(browser1.get());
 
   TabStripModel* tab_strip_model1 = browser1->tab_strip_model();
-  CreateTestWebContents(tab_strip_model1, url1_, false /* is_active */);
-  CreateTestWebContents(tab_strip_model1, url2_, true /* is_active */);
-  const ukm::SourceId source_id1 = GetSourceIdForUrl(url1_);
-  const ukm::SourceId source_id2 = GetSourceIdForUrl(url2_);
+  const ukm::SourceId source_id1 =
+      CreateTestWebContents(tab_strip_model1, url1_, false /* is_active */);
+  const ukm::SourceId source_id2 =
+      CreateTestWebContents(tab_strip_model1, url2_, true /* is_active */);
 
   TabStripModel* tab_strip_model2 = browser2->tab_strip_model();
-  CreateTestWebContents(tab_strip_model2, url3_, true /* is_active */);
-  const ukm::SourceId source_id3 = GetSourceIdForUrl(url3_);
+  const ukm::SourceId source_id3 =
+      CreateTestWebContents(tab_strip_model2, url3_, true /* is_active */);
 
   TabStripModel* tab_strip_model3 = browser3->tab_strip_model();
-  CreateTestWebContents(tab_strip_model3, url4_, true /* is_active */);
-  const ukm::SourceId source_id4 = GetSourceIdForUrl(url4_);
+  const ukm::SourceId source_id4 =
+      CreateTestWebContents(tab_strip_model3, url4_, true /* is_active */);
 
   UpdateOpenTabsURLs();
 

chrome/browser/metrics/process_memory_metrics_emitter_browsertest.cc

@@ -221,160 +221,134 @@ class ProcessMemoryMetricsEmitterTest : public ExtensionBrowserTest {
  protected:
   std::unique_ptr<ukm::TestAutoSetUkmRecorder> test_ukm_recorder_;
 
-  void CheckMetricWithName(ukm::SourceId source_id,
+  void CheckMetricWithName(const ukm::mojom::UkmEntry* entry,
                            const char* name,
-                           std::function<bool(int64_t)> check,
-                           size_t metric_count) {
-    std::vector<int64_t> metrics = test_ukm_recorder_->GetMetricValues(
-        source_id, UkmEntry::kEntryName, name);
-    EXPECT_EQ(metric_count, metrics.size()) << name;
-    if (metrics.size() > 0) {
-      // The check should be performed on the last entry.
-      int64_t metric = metrics.back();
-      EXPECT_TRUE(check(metric)) << name;
-    }
+                           std::function<bool(int64_t)> check) {
+    const int64_t* value = test_ukm_recorder_->GetEntryMetric(entry, name);
+    EXPECT_TRUE(value && check(*value)) << name;
   }
 
-  void CheckExactMetricWithName(ukm::SourceId source_id,
+  void CheckExactMetricWithName(const ukm::mojom::UkmEntry* entry,
                                 const char* name,
-                                int64_t expected_value,
-                                size_t metric_count) {
-    CheckMetricWithName(source_id, name,
-                        [expected_value](int64_t value) -> bool {
-                          return value == expected_value;
-                        },
-                        metric_count);
+                                int64_t expected_value) {
+    CheckMetricWithName(entry, name, [expected_value](int64_t value) -> bool {
+      return value == expected_value;
+    });
   }
 
-  void CheckMemoryMetricWithName(ukm::SourceId source_id,
+  void CheckMemoryMetricWithName(const ukm::mojom::UkmEntry* entry,
                                  const char* name,
-                                 bool can_be_zero,
-                                 size_t metric_count = 1u) {
-    CheckMetricWithName(source_id, name,
-                        [can_be_zero](int64_t value) -> bool {
-                          return value >= (can_be_zero ? 0 : 1) &&
-                                 value <= 4000;
-                        },
-                        metric_count);
+                                 bool can_be_zero) {
+    CheckMetricWithName(entry, name, [can_be_zero](int64_t value) -> bool {
+      return value >= (can_be_zero ? 0 : 1) && value <= 4000;
+    });
   }
 
-  void CheckTimeMetricWithName(ukm::SourceId source_id,
-                               const char* name,
-                               size_t metric_count = 1u) {
-    CheckMetricWithName(
-        source_id, name,
-        [](int64_t value) -> bool { return value >= 0 && value <= 10; },
-        metric_count);
+  void CheckTimeMetricWithName(const ukm::mojom::UkmEntry* entry,
+                               const char* name) {
+    CheckMetricWithName(entry, name, [](int64_t value) -> bool {
+      return value >= 0 && value <= 10;
+    });
   }
 
-  void CheckAllUkmSources(size_t metric_count = 1u) {
-    std::set<ukm::SourceId> source_ids = test_ukm_recorder_->GetSourceIds();
-    bool has_browser_source = false;
-    bool has_renderer_source = false;
-    bool has_total_source = false;
-    for (auto source_id : source_ids) {
-      // Ignore sources with no entries.
-      const ukm::UkmSource* source =
-          test_ukm_recorder_->GetSourceForSourceId(source_id);
-      if (source &&
-          !test_ukm_recorder_->HasEntry(*source, UkmEntry::kEntryName))
-        continue;
-      if (ProcessHasTypeForSource(source_id, ProcessType::BROWSER)) {
-        has_browser_source = true;
-        CheckUkmBrowserSource(source_id, 1);
-      } else if (ProcessHasTypeForSource(source_id, ProcessType::RENDERER)) {
-        // Renderer metrics associate with navigation's source, instead of
-        // creating a new one.
-        has_renderer_source = true;
-        CheckUkmRendererSource(source_id, metric_count);
-      } else if (ProcessHasTypeForSource(source_id, ProcessType::GPU)) {
-        CheckUkmGPUSource(source_id, 1);
+  void CheckAllUkmEntries(size_t entry_count = 1u) {
+    const auto& entries =
+        test_ukm_recorder_->GetEntriesByName(UkmEntry::kEntryName);
+    size_t browser_entry_count = 0;
+    size_t renderer_entry_count = 0;
+    size_t total_entry_count = 0;
+
+    for (const auto* entry : entries) {
+      if (ProcessHasTypeForEntry(entry, ProcessType::BROWSER)) {
+        browser_entry_count++;
+        CheckUkmBrowserEntry(entry);
+      } else if (ProcessHasTypeForEntry(entry, ProcessType::RENDERER)) {
+        renderer_entry_count++;
+        CheckUkmRendererEntry(entry);
+      } else if (ProcessHasTypeForEntry(entry, ProcessType::GPU)) {
+        CheckUkmGPUEntry(entry);
       } else {
         // This must be Total2.
-        has_total_source = true;
+        total_entry_count++;
         CheckMemoryMetricWithName(
-            source_id, UkmEntry::kTotal2_PrivateMemoryFootprintName, false, 1);
+            entry, UkmEntry::kTotal2_PrivateMemoryFootprintName, false);
       }
     }
-    EXPECT_TRUE(has_browser_source);
-    EXPECT_TRUE(has_renderer_source);
-    EXPECT_TRUE(has_total_source);
+    EXPECT_EQ(entry_count, browser_entry_count);
+    EXPECT_EQ(entry_count, total_entry_count);
+
+    EXPECT_GE(renderer_entry_count, entry_count);
   }
 
-  void CheckUkmRendererSource(ukm::SourceId source_id, size_t metric_count) {
+  void CheckUkmRendererEntry(const ukm::mojom::UkmEntry* entry) {
 #if !defined(OS_WIN)
-    CheckMemoryMetricWithName(source_id, UkmEntry::kMallocName, false,
-                              metric_count);
+    CheckMemoryMetricWithName(entry, UkmEntry::kMallocName, false);
 #endif
 #if !defined(OS_MACOSX)
-    CheckMemoryMetricWithName(source_id, UkmEntry::kResidentName, false,
-                              metric_count);
+    CheckMemoryMetricWithName(entry, UkmEntry::kResidentName, false);
 #endif
-    CheckMemoryMetricWithName(source_id, UkmEntry::kPrivateMemoryFootprintName,
-                              false, metric_count);
-    CheckMemoryMetricWithName(source_id, UkmEntry::kBlinkGCName, true,
-                              metric_count);
-    CheckMemoryMetricWithName(source_id, UkmEntry::kPartitionAllocName, true,
-                              metric_count);
-    CheckMemoryMetricWithName(source_id, UkmEntry::kV8Name, true, metric_count);
-    CheckMemoryMetricWithName(source_id, UkmEntry::kNumberOfExtensionsName,
-                              true, metric_count);
-    CheckTimeMetricWithName(source_id, UkmEntry::kUptimeName, metric_count);
-
-    CheckMemoryMetricWithName(source_id, UkmEntry::kNumberOfDocumentsName, true,
-                              metric_count);
-    CheckMemoryMetricWithName(source_id, UkmEntry::kNumberOfFramesName, true,
-                              metric_count);
-    CheckMemoryMetricWithName(source_id, UkmEntry::kNumberOfLayoutObjectsName,
-                              true, metric_count);
-    CheckMemoryMetricWithName(source_id, UkmEntry::kNumberOfNodesName, true,
-                              metric_count);
+    CheckMemoryMetricWithName(entry, UkmEntry::kPrivateMemoryFootprintName,
+                              false);
+    CheckMemoryMetricWithName(entry, UkmEntry::kBlinkGCName, true);
+    CheckMemoryMetricWithName(entry, UkmEntry::kPartitionAllocName, true);
+    CheckMemoryMetricWithName(entry, UkmEntry::kV8Name, true);
+    CheckMemoryMetricWithName(entry, UkmEntry::kNumberOfExtensionsName, true);
+    CheckTimeMetricWithName(entry, UkmEntry::kUptimeName);
+
+    CheckMemoryMetricWithName(entry, UkmEntry::kNumberOfDocumentsName, true);
+    CheckMemoryMetricWithName(entry, UkmEntry::kNumberOfFramesName, true);
+    CheckMemoryMetricWithName(entry, UkmEntry::kNumberOfLayoutObjectsName,
+                              true);
+    CheckMemoryMetricWithName(entry, UkmEntry::kNumberOfNodesName, true);
   }
 
-  void CheckUkmBrowserSource(ukm::SourceId source_id,
-                             size_t metric_count = 1u) {
+  void CheckUkmBrowserEntry(const ukm::mojom::UkmEntry* entry) {
 #if !defined(OS_WIN)
-    CheckMemoryMetricWithName(source_id, UkmEntry::kMallocName, false,
-                              metric_count);
+    CheckMemoryMetricWithName(entry, UkmEntry::kMallocName, false);
 #endif
 #if !defined(OS_MACOSX)
-    CheckMemoryMetricWithName(source_id, UkmEntry::kResidentName, false,
-                              metric_count);
+    CheckMemoryMetricWithName(entry, UkmEntry::kResidentName, false);
 #endif
-    CheckMemoryMetricWithName(source_id, UkmEntry::kPrivateMemoryFootprintName,
-                              false, metric_count);
+    CheckMemoryMetricWithName(entry, UkmEntry::kPrivateMemoryFootprintName,
+                              false);
 
-    CheckTimeMetricWithName(source_id, UkmEntry::kUptimeName, metric_count);
+    CheckTimeMetricWithName(entry, UkmEntry::kUptimeName);
   }
 
-  void CheckUkmGPUSource(ukm::SourceId source_id, size_t metric_count = 1u) {
-    CheckTimeMetricWithName(source_id, UkmEntry::kUptimeName, metric_count);
+  void CheckUkmGPUEntry(const ukm::mojom::UkmEntry* entry) {
+    CheckTimeMetricWithName(entry, UkmEntry::kUptimeName);
   }
 
-  bool ProcessHasTypeForSource(ukm::SourceId source_id,
-                               ProcessType process_type) {
-    std::vector<int64_t> metrics = test_ukm_recorder_->GetMetricValues(
-        source_id, UkmEntry::kEntryName, UkmEntry::kProcessTypeName);
-
-    return std::find(metrics.begin(), metrics.end(),
-                     static_cast<int64_t>(process_type)) != metrics.end();
+  bool ProcessHasTypeForEntry(const ukm::mojom::UkmEntry* entry,
+                              ProcessType process_type) {
+    const int64_t* value =
+        test_ukm_recorder_->GetEntryMetric(entry, UkmEntry::kProcessTypeName);
+    return value && *value == static_cast<int64_t>(process_type);
   }
 
   void CheckPageInfoUkmMetrics(GURL url,
                                bool is_visible,
-                               size_t metric_count = 1u) {
-    const ukm::UkmSource* source = test_ukm_recorder_->GetSourceForUrl(url);
-    EXPECT_TRUE(source) << "Ukm Source for Renderer URL not found";
-    // Only renderer processes has an associated URL.
-    EXPECT_TRUE(ProcessHasTypeForSource(source->id(), ProcessType::RENDERER));
-
-    CheckExactMetricWithName(source->id(), UkmEntry::kIsVisibleName, is_visible,
-                             metric_count);
-    CheckTimeMetricWithName(
-        source->id(), UkmEntry::kTimeSinceLastNavigationName, metric_count);
-    CheckTimeMetricWithName(source->id(),
-                            UkmEntry::kTimeSinceLastVisibilityChangeName,
-                            metric_count);
+                               size_t entry_count = 1u) {
+    const auto& entries =
+        test_ukm_recorder_->GetEntriesByName(UkmEntry::kEntryName);
+    size_t found_count = false;
+    const ukm::mojom::UkmEntry* last_entry = nullptr;
+    for (const auto* entry : entries) {
+      const ukm::UkmSource* source =
+          test_ukm_recorder_->GetSourceForSourceId(entry->source_id);
+      if (!source || source->url() != url)
+        continue;
+      if (!test_ukm_recorder_->EntryHasMetric(entry, UkmEntry::kIsVisibleName))
+        continue;
+      found_count++;
+      last_entry = entry;
+      EXPECT_TRUE(ProcessHasTypeForEntry(entry, ProcessType::RENDERER));
+      CheckTimeMetricWithName(entry, UkmEntry::kTimeSinceLastNavigationName);
+      CheckTimeMetricWithName(entry,
+                              UkmEntry::kTimeSinceLastVisibilityChangeName);
+    }
+    CheckExactMetricWithName(last_entry, UkmEntry::kIsVisibleName, is_visible);
+    EXPECT_EQ(entry_count, found_count);
   }
 
 #if BUILDFLAG(ENABLE_EXTENSIONS)
@@ -456,7 +430,7 @@ IN_PROC_BROWSER_TEST_F(ProcessMemoryMetricsEmitterTest,
   run_loop.Run();
 
   CheckAllMemoryMetrics(histogram_tester, 1);
-  CheckAllUkmSources();
+  CheckAllUkmEntries();
   CheckPageInfoUkmMetrics(url, true);
 }
 
@@ -504,7 +478,7 @@ IN_PROC_BROWSER_TEST_F(ProcessMemoryMetricsEmitterTest,
 
   CheckAllMemoryMetrics(histogram_tester, 1, 1, 2);
   // Extension processes do not have page_info.
-  CheckAllUkmSources();
+  CheckAllUkmEntries();
   CheckPageInfoUkmMetrics(url, true);
 }
 
@@ -549,7 +523,7 @@ IN_PROC_BROWSER_TEST_F(ProcessMemoryMetricsEmitterTest,
 
   // No extensions should be observed
   CheckAllMemoryMetrics(histogram_tester, 1, 1, 0);
-  CheckAllUkmSources();
+  CheckAllUkmEntries();
   CheckPageInfoUkmMetrics(url, true);
 }
 
@@ -596,11 +570,15 @@ IN_PROC_BROWSER_TEST_F(ProcessMemoryMetricsEmitterTest,
   run_loop.Run();
 
   CheckAllMemoryMetrics(histogram_tester, 1, 1, 1);
-  CheckAllUkmSources();
+  CheckAllUkmEntries();
   // When hosts share a process, no unique URL is identified, therefore no page
   // info.
-  EXPECT_FALSE(test_ukm_recorder_->HasEntry(
-      *test_ukm_recorder_->GetSourceForUrl(url), UkmEntry::kEntryName));
+  const auto& entries =
+      test_ukm_recorder_->GetEntriesByName(UkmEntry::kEntryName);
+  for (const auto* entry : entries) {
+    EXPECT_EQ(nullptr,
+              test_ukm_recorder_->GetSourceForSourceId(entry->source_id));
+  }
 }
 #endif  // BUILDFLAG(ENABLE_EXTENSIONS)
 
@@ -660,7 +638,7 @@ IN_PROC_BROWSER_TEST_F(ProcessMemoryMetricsEmitterTest,
                   MemoryDumpType::EXPLICITLY_TRIGGERED))));
 
   CheckAllMemoryMetrics(histogram_tester, 1);
-  CheckAllUkmSources();
+  CheckAllUkmEntries();
   CheckPageInfoUkmMetrics(url, true);
 }
 
@@ -692,7 +670,7 @@ IN_PROC_BROWSER_TEST_F(ProcessMemoryMetricsEmitterTest, MAYBE_FetchThreeTimes) {
   run_loop.Run();
 
   CheckAllMemoryMetrics(histogram_tester, count);
-  CheckAllUkmSources(count);
+  CheckAllUkmEntries(count);
   CheckPageInfoUkmMetrics(url, true, count);
 }
 
@@ -733,9 +711,10 @@ IN_PROC_BROWSER_TEST_F(ProcessMemoryMetricsEmitterTest,
   }
 
   CheckAllMemoryMetrics(histogram_tester, 1, 2);
-  CheckAllUkmSources();
+  CheckAllUkmEntries();
   CheckPageInfoUkmMetrics(url1, true /* is_visible */);
   CheckPageInfoUkmMetrics(url2, false /* is_visible */);
+
   tab1->WasHidden();
   tab2->WasShown();
   {
@@ -747,7 +726,7 @@ IN_PROC_BROWSER_TEST_F(ProcessMemoryMetricsEmitterTest,
     run_loop.Run();
   }
   CheckAllMemoryMetrics(histogram_tester, 2, 2);
-  CheckAllUkmSources(2);
+  CheckAllUkmEntries(2);
   CheckPageInfoUkmMetrics(url1, false /* is_visible */, 2);
   CheckPageInfoUkmMetrics(url2, true /* is_visible */, 2);
 }

chrome/browser/page_load_metrics/page_load_metrics_browsertest.cc

@@ -1302,10 +1302,10 @@ IN_PROC_BROWSER_TEST_F(PageLoadMetricsBrowserTest,
   std::vector<int64_t> ukm_features;
   for (const auto* entry : entries) {
     test_ukm_recorder_->ExpectEntrySourceHasUrl(entry, url);
-    const auto* metric =
-        test_ukm_recorder_->FindMetric(entry, internal::kUkmUseCounterFeature);
+    const auto* metric = test_ukm_recorder_->GetEntryMetric(
+        entry, internal::kUkmUseCounterFeature);
     EXPECT_TRUE(metric);
-    ukm_features.push_back(metric->value);
+    ukm_features.push_back(*metric);
   }
   EXPECT_THAT(
       ukm_features,
@@ -1340,10 +1340,10 @@ IN_PROC_BROWSER_TEST_F(PageLoadMetricsBrowserTest,
   std::vector<int64_t> ukm_features;
   for (const auto* entry : entries) {
     test_ukm_recorder_->ExpectEntrySourceHasUrl(entry, url);
-    const auto* metric =
-        test_ukm_recorder_->FindMetric(entry, internal::kUkmUseCounterFeature);
+    const auto* metric = test_ukm_recorder_->GetEntryMetric(
+        entry, internal::kUkmUseCounterFeature);
     EXPECT_TRUE(metric);
-    ukm_features.push_back(metric->value);
+    ukm_features.push_back(*metric);
   }
   EXPECT_THAT(ukm_features,
               UnorderedElementsAre(

components/ukm/test_ukm_recorder.cc

@@ -33,30 +33,6 @@ void MergeEntry(const mojom::UkmEntry* in, mojom::UkmEntry* out) {
   }
 }
 
-// Provides a single merged ukm::mojom::UkmEntry proto that contains all metrics
-// from the given |entries|. |entries| must be non-empty, and all |entries| must
-// have the same |source_id| and |event_hash|.
-mojom::UkmEntryPtr GetMergedEntry(
-    const std::vector<const mojom::UkmEntry*>& entries) {
-  EXPECT_FALSE(entries.empty());
-  mojom::UkmEntryPtr merged_entry = mojom::UkmEntry::New();
-  for (const auto* entry : entries) {
-    MergeEntry(entry, merged_entry.get());
-  }
-  return merged_entry;
-}
-
-std::vector<int64_t> GetValuesForMetric(const mojom::UkmEntry* entry,
-                                        const char* metric_name) {
-  std::vector<int64_t> values;
-  const uint64_t metric_hash = base::HashMetricName(metric_name);
-  for (const auto& metric : entry->metrics) {
-    if (metric->metric_hash == metric_hash)
-      values.push_back(metric->value);
-  }
-  return values;
-}
-
 }  // namespace
 
 TestUkmRecorder::TestUkmRecorder() {
@@ -78,35 +54,6 @@ bool TestUkmRecorder::ShouldRestrictToWhitelistedEntries() const {
   return false;
 }
 
-std::set<ukm::SourceId> TestUkmRecorder::GetSourceIds() const {
-  std::set<ukm::SourceId> result;
-  for (const auto& kv : sources()) {
-    result.insert(kv.first);
-  }
-  for (const auto& it : entries()) {
-    result.insert(it->source_id);
-  }
-  return result;
-}
-
-const UkmSource* TestUkmRecorder::GetSourceForUrl(const char* url) const {
-  for (const auto& kv : sources()) {
-    if (kv.second->url() == url)
-      return kv.second.get();
-  }
-  return nullptr;
-}
-
-std::vector<const UkmSource*> TestUkmRecorder::GetSourcesForUrl(
-    const char* url) const {
-  std::vector<const UkmSource*> matching_sources;
-  for (const auto& kv : sources()) {
-    if (kv.second->url() == url)
-      matching_sources.push_back(kv.second.get());
-  }
-  return matching_sources;
-}
-
 const UkmSource* TestUkmRecorder::GetSourceForSourceId(
     SourceId source_id) const {
   const UkmSource* source = nullptr;
@@ -119,20 +66,6 @@ const UkmSource* TestUkmRecorder::GetSourceForSourceId(
   return source;
 }
 
-const mojom::UkmEntry* TestUkmRecorder::GetEntry(size_t entry_num) const {
-  DCHECK_LT(entry_num, entries().size());
-  return entries()[entry_num].get();
-}
-
-const mojom::UkmEntry* TestUkmRecorder::GetEntryForEntryName(
-    const char* entry_name) const {
-  for (const auto& it : entries()) {
-    if (it->event_hash == base::HashMetricName(entry_name))
-      return it.get();
-  }
-  return nullptr;
-}
-
 std::vector<const mojom::UkmEntry*> TestUkmRecorder::GetEntriesByName(
     base::StringPiece entry_name) const {
   uint64_t hash = base::HashMetricName(entry_name);
@@ -159,12 +92,6 @@ TestUkmRecorder::GetMergedEntriesByName(base::StringPiece entry_name) const {
   return result;
 }
 
-// static
-bool TestUkmRecorder::EntryHasMetric(const mojom::UkmEntry* entry,
-                                     base::StringPiece metric_name) {
-  return FindMetric(entry, metric_name) != nullptr;
-}
-
 void TestUkmRecorder::ExpectEntrySourceHasUrl(const mojom::UkmEntry* entry,
                                               const GURL& url) const {
   const UkmSource* src = GetSourceForSourceId(entry->source_id);
@@ -175,172 +102,33 @@ void TestUkmRecorder::ExpectEntrySourceHasUrl(const mojom::UkmEntry* entry,
   EXPECT_EQ(src->url(), url);
 }
 
+// static
+bool TestUkmRecorder::EntryHasMetric(const mojom::UkmEntry* entry,
+                                     base::StringPiece metric_name) {
+  return GetEntryMetric(entry, metric_name) != nullptr;
+}
+
 // static
 const int64_t* TestUkmRecorder::GetEntryMetric(const mojom::UkmEntry* entry,
                                                base::StringPiece metric_name) {
-  const mojom::UkmMetric* metric = FindMetric(entry, metric_name);
-  return metric ? &metric->value : nullptr;
+  uint64_t hash = base::HashMetricName(metric_name);
+  for (const auto& metric : entry->metrics) {
+    if (metric->metric_hash == hash)
+      return &metric->value;
+  }
+  return nullptr;
 }
 
 // static
 void TestUkmRecorder::ExpectEntryMetric(const mojom::UkmEntry* entry,
                                         base::StringPiece metric_name,
                                         int64_t expected_value) {
-  const mojom::UkmMetric* metric = FindMetric(entry, metric_name);
+  const int64_t* metric = GetEntryMetric(entry, metric_name);
   if (metric == nullptr) {
     FAIL() << "Failed to find metric for event: " << metric_name;
     return;
   }
-  EXPECT_EQ(metric->value, expected_value) << " for metric:" << metric_name;
-}
-
-// static
-const mojom::UkmMetric* TestUkmRecorder::FindMetric(
-    const mojom::UkmEntry* entry,
-    base::StringPiece metric_name) {
-  uint64_t hash = base::HashMetricName(metric_name);
-  for (const auto& metric : entry->metrics) {
-    if (metric->metric_hash == hash)
-      return metric.get();
-  }
-  return nullptr;
-}
-
-std::vector<const mojom::UkmEntry*> TestUkmRecorder::GetEntriesForSourceID(
-    SourceId source_id,
-    const char* event_name) const {
-  const uint64_t event_hash = base::HashMetricName(event_name);
-  std::vector<const mojom::UkmEntry*> entries;
-  for (size_t i = 0; i < entries_count(); ++i) {
-    const mojom::UkmEntry* entry = GetEntry(i);
-    if (entry->source_id == source_id && entry->event_hash == event_hash) {
-      entries.push_back(entry);
-    }
-  }
-  return entries;
-}
-
-mojom::UkmEntryPtr TestUkmRecorder::GetMergedEntryForSourceID(
-    SourceId source_id,
-    const char* event_name) const {
-  mojom::UkmEntryPtr entry =
-      GetMergedEntry(GetEntriesForSourceID(source_id, event_name));
-  EXPECT_EQ(source_id, entry->source_id);
-  EXPECT_EQ(base::HashMetricName(event_name), entry->event_hash);
-  return entry;
-}
-
-bool TestUkmRecorder::HasEntry(const UkmSource& source,
-                               const char* event_name) const {
-  return CountEntries(source, event_name) > 0;
-}
-
-int TestUkmRecorder::CountEntries(const UkmSource& source,
-                                  const char* event_name) const {
-  return GetEntriesForSourceID(source.id(), event_name).size();
-}
-
-void TestUkmRecorder::ExpectEntry(
-    const UkmSource& source,
-    const char* event_name,
-    const std::vector<std::pair<const char*, int64_t>>& expected_metrics)
-    const {
-  // Produce a sorted view of the expected metrics, since order is not
-  // significant.
-  std::vector<std::pair<uint64_t, int64_t>> sorted_expected_metrics;
-  std::transform(expected_metrics.begin(), expected_metrics.end(),
-                 std::back_inserter(sorted_expected_metrics),
-                 [](const std::pair<const char*, int64_t>& metric) {
-                   return std::make_pair(base::HashMetricName(metric.first),
-                                         metric.second);
-                 });
-  std::sort(sorted_expected_metrics.begin(), sorted_expected_metrics.end());
-
-  std::vector<const mojom::UkmEntry*> candidate_entries =
-      GetEntriesForSourceID(source.id(), event_name);
-
-  // Produce a view of each matching entry's metrics that can be compared with
-  // sorted_expected_metrics.
-  std::vector<std::vector<std::pair<uint64_t, int64_t>>> candidate_metrics;
-  std::transform(
-      candidate_entries.begin(), candidate_entries.end(),
-      std::back_inserter(candidate_metrics),
-      [](const mojom::UkmEntry* candidate_entry) {
-        std::vector<std::pair<uint64_t, int64_t>> metrics;
-        std::transform(
-            candidate_entry->metrics.begin(), candidate_entry->metrics.end(),
-            std::back_inserter(metrics), [](const mojom::UkmMetricPtr& metric) {
-              return std::make_pair(metric->metric_hash, metric->value);
-            });
-        std::sort(metrics.begin(), metrics.end());
-        return metrics;
-      });
-
-  if (std::find(candidate_metrics.begin(), candidate_metrics.end(),
-                sorted_expected_metrics) == candidate_metrics.end()) {
-    FAIL() << "Failed to find metrics for event: " << event_name;
-  }
-}
-
-int TestUkmRecorder::CountMetricsForEventName(const UkmSource& source,
-                                              const char* event_name) const {
-  mojom::UkmEntryPtr entry = GetMergedEntryForSourceID(source.id(), event_name);
-  return entry.get() ? entry->metrics.size() : 0;
-}
-
-bool TestUkmRecorder::HasMetric(const UkmSource& source,
-                                const char* event_name,
-                                const char* metric_name) const {
-  return CountMetrics(source, event_name, metric_name) > 0;
-}
-
-int TestUkmRecorder::CountMetrics(const UkmSource& source,
-                                  const char* event_name,
-                                  const char* metric_name) const {
-  mojom::UkmEntryPtr entry = GetMergedEntryForSourceID(source.id(), event_name);
-  return GetValuesForMetric(entry.get(), metric_name).size();
-}
-
-void TestUkmRecorder::ExpectMetric(const UkmSource& source,
-                                   const char* event_name,
-                                   const char* metric_name,
-                                   int64_t expected_value) const {
-  ExpectMetrics(source, event_name, metric_name, {expected_value});
-}
-
-void TestUkmRecorder::ExpectMetrics(
-    const UkmSource& source,
-    const char* event_name,
-    const char* metric_name,
-    const std::vector<int64_t>& expected_values) const {
-  mojom::UkmEntryPtr entry = GetMergedEntryForSourceID(source.id(), event_name);
-
-  // Make sure both vectors are sorted before comparing, since order is not
-  // significant.
-  std::vector<int64_t> sorted_expected_values(expected_values);
-  std::sort(sorted_expected_values.begin(), sorted_expected_values.end());
-
-  std::vector<int64_t> actual_values =
-      GetValuesForMetric(entry.get(), metric_name);
-  std::sort(actual_values.begin(), actual_values.end());
-
-  EXPECT_EQ(actual_values, sorted_expected_values)
-      << "Failed to find expected_values for metric: " << metric_name;
-}
-
-std::vector<int64_t> TestUkmRecorder::GetMetricValues(
-    ukm::SourceId source_id,
-    const char* event_name,
-    const char* metric_name) const {
-  mojom::UkmEntryPtr entry = GetMergedEntryForSourceID(source_id, event_name);
-  return GetValuesForMetric(entry.get(), metric_name);
-}
-
-std::vector<int64_t> TestUkmRecorder::GetMetrics(
-    const UkmSource& source,
-    const char* event_name,
-    const char* metric_name) const {
-  return GetMetricValues(source.id(), event_name, metric_name);
+  EXPECT_EQ(expected_value, *metric) << " for metric:" << metric_name;
 }
 
 TestAutoSetUkmRecorder::TestAutoSetUkmRecorder() : self_ptr_factory_(this) {

components/ukm/test_ukm_recorder.h

@@ -73,109 +73,7 @@ class TestUkmRecorder : public UkmRecorderImpl {
   static const int64_t* GetEntryMetric(const mojom::UkmEntry* entry,
                                        base::StringPiece metric_name);
 
-  // All of the methods below are deprecated.
-  // Use GetEntriesByName based testing instead.
-  // TODO(crbug/761524): Migrate tests and remove these.
-
-  // Get all SourceIds with any data associated with them.
-  std::set<ukm::SourceId> GetSourceIds() const;
-
-  // Returns the UKM source for the given URL. If there are multiple sources for
-  // the given URL, this returns the first source that is created. If there is
-  // no source for the given URL, this returns nullptr.
-  const UkmSource* GetSourceForUrl(const char* url) const;
-  const UkmSource* GetSourceForUrl(const GURL& url) const {
-    return GetSourceForUrl(url.spec().c_str());
-  }
-  std::vector<const ukm::UkmSource*> GetSourcesForUrl(const char* url) const;
-
-  // Returns whether the given UKM |source| has an entry with the given
-  // |event_name|.
-  bool HasEntry(const ukm::UkmSource& source,
-                const char* event_name) const WARN_UNUSED_RESULT;
-
-  // Returns the number of metrics recorded for the given UKM |source| and
-  // |event_name|.
-  int CountMetricsForEventName(const ukm::UkmSource& source,
-                               const char* event_name) const;
-
-  // Returns whether a metric with the given |metric_name| was recorded for the
-  // given UKM |source| and |event_name|.
-  bool HasMetric(const ukm::UkmSource& source,
-                 const char* event_name,
-                 const char* metric_name) const WARN_UNUSED_RESULT;
-
-  // Returns the number of metrics recorded with the given |metric_name|, for
-  // the given UKM |source| and |event_name|.
-  int CountMetrics(const ukm::UkmSource& source,
-                   const char* event_name,
-                   const char* metric_name) const WARN_UNUSED_RESULT;
-
-  // Expects that a single metric was recorded with the given |expected_value|,
-  // for the given |source| and |event_name|. This is shorthand for calling
-  // ExpectMetrics with a single value in the expected values vector.
-  void ExpectMetric(const ukm::UkmSource& source,
-                    const char* event_name,
-                    const char* metric_name,
-                    int64_t expected_value) const;
-
-  // Expects that metrics were recorded with the given |expected_values|, for
-  // the given |source| and |event_name|. The order of |expected_values| is not
-  // significant.
-  void ExpectMetrics(const ukm::UkmSource& source,
-                     const char* event_name,
-                     const char* metric_name,
-                     const std::vector<int64_t>& expected_values) const;
-
-  // Returns all recorded values of a metric for the given |source|,
-  // |event_name| and |metric_name|. The order of values is not specified.
-  std::vector<int64_t> GetMetricValues(ukm::SourceId source_id,
-                                       const char* event_name,
-                                       const char* metric_name) const;
-
-  // Deprecated.
-  // Returns all collected metrics for the given |source|, |event_name| and
-  // |metric_name|. The order of values is not specified.
-  std::vector<int64_t> GetMetrics(const UkmSource& source,
-                                  const char* event_name,
-                                  const char* metric_name) const;
-
-  // UKM entries that may be recorded multiple times for a single source may
-  // need to verify that an expected number of UKM entries were logged. The
-  // utility methods below can be used to verify expected entries. UKM entries
-  // that aren't recorded multiple times per source should prefer using
-  // HasMetric/CountMetrics/ExpectMetric(s) above.
-
-  // Returns the number of entries recorded with the given |event_name|, for the
-  // given UKM |source|.
-  int CountEntries(const ukm::UkmSource& source, const char* event_name) const;
-
-  // Expects that an entry with the given |expected_metrics| was recorded, for
-  // the given |source| and |event_name|. The order of |expected_metrics| is not
-  // significant. |expected_metrics| contains (metric name,metric value) pairs.
-  void ExpectEntry(const ukm::UkmSource& source,
-                   const char* event_name,
-                   const std::vector<std::pair<const char*, int64_t>>&
-                       expected_metrics) const;
-
-  // Deprecated.
-  const mojom::UkmEntry* GetEntry(size_t entry_num) const;
-  // Deprecated.
-  const mojom::UkmEntry* GetEntryForEntryName(const char* entry_name) const;
-
-  // Deprecated.
-  static const mojom::UkmMetric* FindMetric(const mojom::UkmEntry* entry,
-                                            base::StringPiece metric_name);
-
  private:
-  ukm::mojom::UkmEntryPtr GetMergedEntryForSourceID(
-      ukm::SourceId source_id,
-      const char* event_name) const;
-
-  std::vector<const ukm::mojom::UkmEntry*> GetEntriesForSourceID(
-      ukm::SourceId source_id,
-      const char* event_name) const;
-
   DISALLOW_COPY_AND_ASSIGN(TestUkmRecorder);
 };