[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>

[michaeln, 2016/10/05 23:27:45]

ditto <>'s and blank line

[dmurph, 2016/10/06 01:01:59]

Done.

 #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"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
@@ skipping 234 matching lines @@
   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)));
 }