[Durable] Updated Durable heuristic to use 'important sites'

chrome/browser/engagement/important_sites_util_unittest.cc

 // Copyright 2016 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 "chrome/browser/android/preferences/important_sites_util.h"
+#include "chrome/browser/engagement/important_sites_util.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sample_vector.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/histogram_tester.h"
@@ skipping 46 matching lines @@
   CROSSED_NOTIFICATIONS_AND_ENGAGEMENT = 3,
   CROSSED_REASON_UNKNOWN = 7,
 };
 
 }  // namespace
 
 class ImportantSitesUtilTest : public ChromeRenderViewHostTestHarness {
  public:
   void SetUp() override {
     ChromeRenderViewHostTestHarness::SetUp();
+    SiteEngagementScore::SetParamValuesForTesting();
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     g_temp_history_dir = temp_dir_.GetPath();
     HistoryServiceFactory::GetInstance()->SetTestingFactory(
         profile(), &BuildTestHistoryService);
-    SiteEngagementScore::SetParamValuesForTesting();
   }
 
   void AddContentSetting(ContentSettingsType type,
                          ContentSetting setting,
                          const GURL& origin) {
     HostContentSettingsMapFactory::GetForProfile(profile())
         ->SetContentSettingCustomScope(
             ContentSettingsPattern::FromURLNoWildcard(origin),
             ContentSettingsPattern::Wildcard(), type,
             content_settings::ResourceIdentifier(), setting);
@@ skipping 19 matching lines @@
       const std::vector<GURL>& expected_sorted_origins,
       const std::vector<ImportantDomainInfo>& important_sites) {
     ASSERT_EQ(domains.size(), important_sites.size());
     ASSERT_EQ(expected_sorted_origins.size(), important_sites.size());
     for (size_t i = 0; i < important_sites.size(); i++) {
       EXPECT_EQ(domains[i], important_sites[i].registerable_domain);
       EXPECT_EQ(expected_sorted_origins[i], important_sites[i].example_origin);
     }
   }
 
+  void ExpectImportantResultsEqualUnordered(
+      const std::vector<std::string>& domains,
+      const std::vector<GURL>& expected_sorted_origins,
+      const std::vector<ImportantDomainInfo>& important_sites) {
+    ASSERT_EQ(domains.size(), important_sites.size());
+    ASSERT_EQ(expected_sorted_origins.size(), important_sites.size());
+
+    std::vector<std::string> actual_domains;
+    std::vector<GURL> actual_origins;
+    for (size_t i = 0; i < important_sites.size(); i++) {
+      actual_domains.push_back(important_sites[i].registerable_domain);
+      actual_origins.push_back(important_sites[i].example_origin);
+    }
+    EXPECT_THAT(actual_domains, testing::UnorderedElementsAreArray(domains));
+    EXPECT_THAT(actual_origins,
+                testing::UnorderedElementsAreArray(expected_sorted_origins));
+  }
+
  private:
   base::ScopedTempDir temp_dir_;
   BookmarkModel* model_ = nullptr;
 };
 
 TEST_F(ImportantSitesUtilTest, TestNoImportantSites) {
   EXPECT_TRUE(ImportantSitesUtil::GetImportantRegisterableDomains(
                   profile(), kNumImportantSites)
                   .empty());
 }
@@ skipping 86 matching lines @@
   EXPECT_EQ(3u, important_sites.size());
 
   // Add the rest, which should put us over the limit.
   AddBookmark(url6);
   AddBookmark(url7);
   // Too many bookmarks! Nothing shows up now.
   important_sites = ImportantSitesUtil::GetImportantRegisterableDomains(
       profile(), kNumImportantSites);
   EXPECT_EQ(0u, important_sites.size());
 
-  // If we add some site engagement, these should show up in order (even though
-  // the engagement is too low for a signal by itself).
+  // If we add some site engagement, they should show up (even though the site
+  // engagement score is too low for a signal by itself).
   service->ResetScoreForURL(url1, 2);
   service->ResetScoreForURL(url4, 3);
   service->ResetScoreForURL(url7, 0);
 
   important_sites = ImportantSitesUtil::GetImportantRegisterableDomains(
       profile(), kNumImportantSites);
   ASSERT_EQ(2u, important_sites.size());
   std::vector<std::string> expected_sorted_domains = {"google.com",
                                                       "chrome.com"};
   std::vector<GURL> expected_sorted_origins = {url1, url4};
-  ExpectImportantResultsEq(expected_sorted_domains, expected_sorted_origins,
-                           important_sites);
+  ExpectImportantResultsEqualUnordered(
+      expected_sorted_domains, expected_sorted_origins, important_sites);
 }
 
 TEST_F(ImportantSitesUtilTest, Blacklisting) {
   SiteEngagementService* service = SiteEngagementService::Get(profile());
   ASSERT_TRUE(service);
 
   GURL url1("http://www.google.com/");
 
   // Set a bunch of positive signals.
   service->ResetScoreForURL(url1, 5);
   AddBookmark(url1);
   AddContentSetting(CONTENT_SETTINGS_TYPE_NOTIFICATIONS, CONTENT_SETTING_ALLOW,
                     url1);
 
   // Important fetch 1.
   std::vector<ImportantDomainInfo> important_sites =
       ImportantSitesUtil::GetImportantRegisterableDomains(profile(),
                                                           kNumImportantSites);
   std::vector<std::string> expected_sorted_domains = {"google.com"};
   std::vector<GURL> expected_sorted_origins = {url1};
   ExpectImportantResultsEq(expected_sorted_domains, expected_sorted_origins,
                            important_sites);
   ASSERT_EQ(1u, important_sites.size());
   // Record ignore twice.
   ImportantSitesUtil::RecordBlacklistedAndIgnoredImportantSites(
-      profile(), {}, {}, {"google.com"}, {important_sites[0].reason_bitfield});
+      profile(), std::vector<std::string>(), std::vector<int32_t>(),
+      {"google.com"}, {important_sites[0].reason_bitfield});
   ImportantSitesUtil::RecordBlacklistedAndIgnoredImportantSites(
-      profile(), {}, {}, {"google.com"}, {important_sites[0].reason_bitfield});
+      profile(), std::vector<std::string>(), std::vector<int32_t>(),
+      {"google.com"}, {important_sites[0].reason_bitfield});
 
   // Important fetch 2.
   important_sites = ImportantSitesUtil::GetImportantRegisterableDomains(
       profile(), kNumImportantSites);
   ExpectImportantResultsEq(expected_sorted_domains, expected_sorted_origins,
                            important_sites);
   // We shouldn't blacklist after first two times.
   ASSERT_EQ(1u, important_sites.size());
 
   // Record ignore 3rd time.
   ImportantSitesUtil::RecordBlacklistedAndIgnoredImportantSites(
-      profile(), {}, {}, {"google.com"}, {important_sites[0].reason_bitfield});
+      profile(), std::vector<std::string>(), std::vector<int32_t>(),
+      {"google.com"}, {important_sites[0].reason_bitfield});
 
   // Important fetch 3. We should be blacklisted now.
   important_sites = ImportantSitesUtil::GetImportantRegisterableDomains(
       profile(), kNumImportantSites);
   ASSERT_EQ(0u, important_sites.size());
 }
 
 TEST_F(ImportantSitesUtilTest, BlacklistingReset) {
   SiteEngagementService* service = SiteEngagementService::Get(profile());
   ASSERT_TRUE(service);
 
   GURL url1("http://www.google.com/");
 
   // Set a bunch of positive signals.
   service->ResetScoreForURL(url1, 5);
   AddBookmark(url1);
   AddContentSetting(CONTENT_SETTINGS_TYPE_NOTIFICATIONS, CONTENT_SETTING_ALLOW,
                     url1);
 
   std::vector<ImportantDomainInfo> important_sites =
       ImportantSitesUtil::GetImportantRegisterableDomains(profile(),
                                                           kNumImportantSites);
 
   // Record ignored twice.
   ASSERT_EQ(1u, important_sites.size());
   ImportantSitesUtil::RecordBlacklistedAndIgnoredImportantSites(
-      profile(), {}, {}, {"google.com"}, {important_sites[0].reason_bitfield});
+      profile(), std::vector<std::string>(), std::vector<int32_t>(),
+      {"google.com"}, {important_sites[0].reason_bitfield});
   ImportantSitesUtil::RecordBlacklistedAndIgnoredImportantSites(
-      profile(), {}, {}, {"google.com"}, {important_sites[0].reason_bitfield});
+      profile(), std::vector<std::string>(), std::vector<int32_t>(),
+      {"google.com"}, {important_sites[0].reason_bitfield});
 
   // Important fetch, we should still be there.
   important_sites = ImportantSitesUtil::GetImportantRegisterableDomains(
       profile(), kNumImportantSites);
   std::vector<std::string> expected_sorted_domains = {"google.com"};
   std::vector<GURL> expected_sorted_origins = {url1};
   ASSERT_EQ(1u, important_sites.size());
   ExpectImportantResultsEq(expected_sorted_domains, expected_sorted_origins,
                            important_sites);
 
   // Record NOT ignored.
   ImportantSitesUtil::RecordBlacklistedAndIgnoredImportantSites(
-      profile(), {"google.com"}, {important_sites[0].reason_bitfield}, {}, {});
+      profile(), {"google.com"}, {important_sites[0].reason_bitfield},
+      std::vector<std::string>(), std::vector<int32_t>());
 
   // Record ignored twice again.
   ImportantSitesUtil::RecordBlacklistedAndIgnoredImportantSites(
-      profile(), {}, {}, {"google.com"}, {important_sites[0].reason_bitfield});
+      profile(), std::vector<std::string>(), std::vector<int32_t>(),
+      {"google.com"}, {important_sites[0].reason_bitfield});
   ImportantSitesUtil::RecordBlacklistedAndIgnoredImportantSites(
-      profile(), {}, {}, {"google.com"}, {important_sites[0].reason_bitfield});
+      profile(), std::vector<std::string>(), std::vector<int32_t>(),
+      {"google.com"}, {important_sites[0].reason_bitfield});
 
   // Important fetch, we should still be there.
   important_sites = ImportantSitesUtil::GetImportantRegisterableDomains(
       profile(), kNumImportantSites);
   ExpectImportantResultsEq(expected_sorted_domains, expected_sorted_origins,
                            important_sites);
 
   // Record ignored 3rd time in a row.
   ImportantSitesUtil::RecordBlacklistedAndIgnoredImportantSites(
-      profile(), {}, {}, {"google.com"}, {important_sites[0].reason_bitfield});
+      profile(), std::vector<std::string>(), std::vector<int32_t>(),
+      {"google.com"}, {important_sites[0].reason_bitfield});
 
   // Blacklisted now.
   important_sites = ImportantSitesUtil::GetImportantRegisterableDomains(
       profile(), kNumImportantSites);
   EXPECT_EQ(0u, important_sites.size());
 }
 
 TEST_F(ImportantSitesUtilTest, Metrics) {
   SiteEngagementService* service = SiteEngagementService::Get(profile());
   ASSERT_TRUE(service);
@@ skipping 12 matching lines @@
 
   std::vector<ImportantDomainInfo> important_sites =
       ImportantSitesUtil::GetImportantRegisterableDomains(profile(),
                                                           kNumImportantSites);
 
   ImportantSitesUtil::RecordBlacklistedAndIgnoredImportantSites(
       profile(), {"google.com", "youtube.com"},
       {important_sites[0].reason_bitfield, important_sites[1].reason_bitfield},
       {"bad.com"}, {important_sites[2].reason_bitfield});
 
-  EXPECT_THAT(histogram_tester.GetAllSamples(
-                  "Storage.ImportantSites.CBDChosenReason"),
-              testing::ElementsAre(
-                  base::Bucket(ENGAGEMENT, 1),
-                  base::Bucket(BOOKMARKS, 1),
-                  base::Bucket(NOTIFICATIONS, 1)));
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("Storage.ImportantSites.CBDChosenReason"),
+      testing::ElementsAre(base::Bucket(ENGAGEMENT, 1),
+                           base::Bucket(BOOKMARKS, 1),
+                           base::Bucket(NOTIFICATIONS, 1)));
 
   EXPECT_THAT(
       histogram_tester.GetAllSamples("Storage.ImportantSites.CBDIgnoredReason"),
       testing::ElementsAre(base::Bucket(BOOKMARKS, 1)));
 
   // Bookmarks are "unknown", as they were added after the crossed reasons.
   EXPECT_THAT(histogram_tester.GetAllSamples(
                   "Storage.BlacklistedImportantSites.Reason"),
               testing::ElementsAre(
                   base::Bucket(CROSSED_NOTIFICATIONS_AND_ENGAGEMENT, 1),
                   base::Bucket(CROSSED_REASON_UNKNOWN, 1)));
 }