Reduce the site engagement service public interface.

chrome/browser/engagement/site_engagement_service_unittest.cc

 // Copyright 2015 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/engagement/site_engagement_service.h"
 
 #include <utility>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/test/histogram_tester.h"
 #include "base/test/simple_test_clock.h"
 #include "base/values.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/engagement/site_engagement_helper.h"
 #include "chrome/browser/engagement/site_engagement_metrics.h"
-#include "chrome/browser/engagement/site_engagement_service_factory.h"
+#include "chrome/browser/engagement/site_engagement_score.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/content_settings/core/browser/content_settings_observer.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/history/core/browser/history_database_params.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/history/core/test/test_history_database.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/page_navigator.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/web_contents_tester.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 base::FilePath g_temp_history_dir;
 
-const int kLessAccumulationsThanNeededToMaxDailyEngagement = 2;
 const int kMoreAccumulationsThanNeededToMaxDailyEngagement = 40;
-const int kMoreAccumulationsThanNeededToMaxTotalEngagement = 200;
-const int kLessDaysThanNeededToMaxTotalEngagement = 4;
 const int kMoreDaysThanNeededToMaxTotalEngagement = 40;
 const int kLessPeriodsThanNeededToDecayMaxScore = 2;
 const int kMorePeriodsThanNeededToDecayMaxScore = 40;
 
 // Waits until a change is observed in site engagement content settings.
 class SiteEngagementChangeWaiter : public content_settings::Observer {
  public:
   explicit SiteEngagementChangeWaiter(Profile* profile) : profile_(profile) {
     HostContentSettingsMapFactory::GetForProfile(profile)->AddObserver(this);
   }
   ~SiteEngagementChangeWaiter() override {
-    HostContentSettingsMapFactory::GetForProfile(profile_)
-        ->RemoveObserver(this);
+    HostContentSettingsMapFactory::GetForProfile(profile_)->RemoveObserver(
+        this);
   }
 
   // Overridden from content_settings::Observer:
   void OnContentSettingChanged(const ContentSettingsPattern& primary_pattern,
                                const ContentSettingsPattern& secondary_pattern,
                                ContentSettingsType content_type,
                                std::string resource_identifier) override {
     if (content_type == CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT)
       Proceed();
   }
@@ skipping 26 matching lines @@
 std::unique_ptr<KeyedService> BuildTestHistoryService(
     content::BrowserContext* context) {
   std::unique_ptr<history::HistoryService> service(
       new history::HistoryService());
   service->Init(history::TestHistoryDatabaseParamsForPath(g_temp_history_dir));
   return std::move(service);
 }
 
 }  // namespace
 
-class SiteEngagementScoreTest : public testing::Test {
- public:
-  SiteEngagementScoreTest() : score_(&test_clock_) {}
-
-  void SetUp() override {
-    testing::Test::SetUp();
-    // Disable the first engagement bonus for tests.
-    SiteEngagementScore::SetParamValuesForTesting();
-  }
-
- protected:
-  void VerifyScore(const SiteEngagementScore& score,
-                   double expected_raw_score,
-                   double expected_points_added_today,
-                   base::Time expected_last_engagement_time) {
-    EXPECT_EQ(expected_raw_score, score.raw_score_);
-    EXPECT_EQ(expected_points_added_today, score.points_added_today_);
-    EXPECT_EQ(expected_last_engagement_time, score.last_engagement_time_);
-  }
-
-  void UpdateScore(SiteEngagementScore* score,
-                   double raw_score,
-                   double points_added_today,
-                   base::Time last_engagement_time) {
-    score->raw_score_ = raw_score;
-    score->points_added_today_ = points_added_today;
-    score->last_engagement_time_ = last_engagement_time;
-  }
-
-  void TestScoreInitializesAndUpdates(
-      base::DictionaryValue* score_dict,
-      double expected_raw_score,
-      double expected_points_added_today,
-      base::Time expected_last_engagement_time) {
-    SiteEngagementScore initial_score(&test_clock_, *score_dict);
-    VerifyScore(initial_score, expected_raw_score, expected_points_added_today,
-                expected_last_engagement_time);
-
-    // Updating the score dict should return false, as the score shouldn't
-    // have changed at this point.
-    EXPECT_FALSE(initial_score.UpdateScoreDict(score_dict));
-
-    // Update the score to new values and verify it updates the score dict
-    // correctly.
-    base::Time different_day =
-        GetReferenceTime() + base::TimeDelta::FromDays(1);
-    UpdateScore(&initial_score, 5, 10, different_day);
-    EXPECT_TRUE(initial_score.UpdateScoreDict(score_dict));
-    SiteEngagementScore updated_score(&test_clock_, *score_dict);
-    VerifyScore(updated_score, 5, 10, different_day);
-  }
-
-  void SetFirstDailyEngagementPointsForTesting(double points) {
-    SiteEngagementScore::param_values
-        [SiteEngagementScore::FIRST_DAILY_ENGAGEMENT] = points;
-  }
-
-  base::SimpleTestClock test_clock_;
-  SiteEngagementScore score_;
-};
-
-// Accumulate score many times on the same day. Ensure each time the score goes
-// up, but not more than the maximum per day.
-TEST_F(SiteEngagementScoreTest, AccumulateOnSameDay) {
-  base::Time reference_time = GetReferenceTime();
-
-  test_clock_.SetNow(reference_time);
-  for (int i = 0; i < kMoreAccumulationsThanNeededToMaxDailyEngagement; ++i) {
-    score_.AddPoints(SiteEngagementScore::GetNavigationPoints());
-    EXPECT_EQ(std::min(SiteEngagementScore::GetMaxPointsPerDay(),
-                       (i + 1) * SiteEngagementScore::GetNavigationPoints()),
-              score_.Score());
-  }
-
-  EXPECT_EQ(SiteEngagementScore::GetMaxPointsPerDay(), score_.Score());
-}
-
-// Accumulate on the first day to max that day's engagement, then accumulate on
-// a different day.
-TEST_F(SiteEngagementScoreTest, AccumulateOnTwoDays) {
-  base::Time reference_time = GetReferenceTime();
-  base::Time later_date = reference_time + base::TimeDelta::FromDays(2);
-
-  test_clock_.SetNow(reference_time);
-  for (int i = 0; i < kMoreAccumulationsThanNeededToMaxDailyEngagement; ++i)
-    score_.AddPoints(SiteEngagementScore::GetNavigationPoints());
-
-  EXPECT_EQ(SiteEngagementScore::GetMaxPointsPerDay(), score_.Score());
-
-  test_clock_.SetNow(later_date);
-  for (int i = 0; i < kMoreAccumulationsThanNeededToMaxDailyEngagement; ++i) {
-    score_.AddPoints(SiteEngagementScore::GetNavigationPoints());
-    double day_score =
-        std::min(SiteEngagementScore::GetMaxPointsPerDay(),
-                 (i + 1) * SiteEngagementScore::GetNavigationPoints());
-    EXPECT_EQ(day_score + SiteEngagementScore::GetMaxPointsPerDay(),
-              score_.Score());
-  }
-
-  EXPECT_EQ(2 * SiteEngagementScore::GetMaxPointsPerDay(), score_.Score());
-}
-
-// Accumulate score on many consecutive days and ensure the score doesn't exceed
-// the maximum allowed.
-TEST_F(SiteEngagementScoreTest, AccumulateALotOnManyDays) {
-  base::Time current_day = GetReferenceTime();
-
-  for (int i = 0; i < kMoreDaysThanNeededToMaxTotalEngagement; ++i) {
-    current_day += base::TimeDelta::FromDays(1);
-    test_clock_.SetNow(current_day);
-    for (int j = 0; j < kMoreAccumulationsThanNeededToMaxDailyEngagement; ++j)
-      score_.AddPoints(SiteEngagementScore::GetNavigationPoints());
-
-    EXPECT_EQ(std::min(SiteEngagementScore::kMaxPoints,
-                       (i + 1) * SiteEngagementScore::GetMaxPointsPerDay()),
-              score_.Score());
-  }
-
-  EXPECT_EQ(SiteEngagementScore::kMaxPoints, score_.Score());
-}
-
-// Accumulate a little on many consecutive days and ensure the score doesn't
-// exceed the maximum allowed.
-TEST_F(SiteEngagementScoreTest, AccumulateALittleOnManyDays) {
-  base::Time current_day = GetReferenceTime();
-
-  for (int i = 0; i < kMoreAccumulationsThanNeededToMaxTotalEngagement; ++i) {
-    current_day += base::TimeDelta::FromDays(1);
-    test_clock_.SetNow(current_day);
-
-    for (int j = 0; j < kLessAccumulationsThanNeededToMaxDailyEngagement; ++j)
-      score_.AddPoints(SiteEngagementScore::GetNavigationPoints());
-
-    EXPECT_EQ(
-        std::min(SiteEngagementScore::kMaxPoints,
-                 (i + 1) * kLessAccumulationsThanNeededToMaxDailyEngagement *
-                     SiteEngagementScore::GetNavigationPoints()),
-        score_.Score());
-  }
-
-  EXPECT_EQ(SiteEngagementScore::kMaxPoints, score_.Score());
-}
-
-// Accumulate a bit, then check the score decays properly for a range of times.
-TEST_F(SiteEngagementScoreTest, ScoresDecayOverTime) {
-  base::Time current_day = GetReferenceTime();
-
-  // First max the score.
-  for (int i = 0; i < kMoreDaysThanNeededToMaxTotalEngagement; ++i) {
-    current_day += base::TimeDelta::FromDays(1);
-    test_clock_.SetNow(current_day);
-
-    for (int j = 0; j < kMoreAccumulationsThanNeededToMaxDailyEngagement; ++j)
-      score_.AddPoints(SiteEngagementScore::GetNavigationPoints());
-  }
-
-  EXPECT_EQ(SiteEngagementScore::kMaxPoints, score_.Score());
-
-  // The score should not have decayed before the first decay period has
-  // elapsed.
-  test_clock_.SetNow(current_day +
-                     base::TimeDelta::FromDays(
-                         SiteEngagementScore::GetDecayPeriodInDays() - 1));
-  EXPECT_EQ(SiteEngagementScore::kMaxPoints, score_.Score());
-
-  // The score should have decayed by one chunk after one decay period has
-  // elapsed.
-  test_clock_.SetNow(
-      current_day +
-      base::TimeDelta::FromDays(SiteEngagementScore::GetDecayPeriodInDays()));
-  EXPECT_EQ(
-      SiteEngagementScore::kMaxPoints - SiteEngagementScore::GetDecayPoints(),
-      score_.Score());
-
-  // The score should have decayed by the right number of chunks after a few
-  // decay periods have elapsed.
-  test_clock_.SetNow(
-      current_day +
-      base::TimeDelta::FromDays(kLessPeriodsThanNeededToDecayMaxScore *
-                                SiteEngagementScore::GetDecayPeriodInDays()));
-  EXPECT_EQ(SiteEngagementScore::kMaxPoints -
-                kLessPeriodsThanNeededToDecayMaxScore *
-                    SiteEngagementScore::GetDecayPoints(),
-            score_.Score());
-
-  // The score should not decay below zero.
-  test_clock_.SetNow(
-      current_day +
-      base::TimeDelta::FromDays(kMorePeriodsThanNeededToDecayMaxScore *
-                                SiteEngagementScore::GetDecayPeriodInDays()));
-  EXPECT_EQ(0, score_.Score());
-}
-
-// Test that any expected decays are applied before adding points.
-TEST_F(SiteEngagementScoreTest, DecaysAppliedBeforeAdd) {
-  base::Time current_day = GetReferenceTime();
-
-  // Get the score up to something that can handle a bit of decay before
-  for (int i = 0; i < kLessDaysThanNeededToMaxTotalEngagement; ++i) {
-    current_day += base::TimeDelta::FromDays(1);
-    test_clock_.SetNow(current_day);
-
-    for (int j = 0; j < kMoreAccumulationsThanNeededToMaxDailyEngagement; ++j)
-      score_.AddPoints(SiteEngagementScore::GetNavigationPoints());
-  }
-
-  double initial_score = kLessDaysThanNeededToMaxTotalEngagement *
-                         SiteEngagementScore::GetMaxPointsPerDay();
-  EXPECT_EQ(initial_score, score_.Score());
-
-  // Go forward a few decay periods.
-  test_clock_.SetNow(
-      current_day +
-      base::TimeDelta::FromDays(kLessPeriodsThanNeededToDecayMaxScore *
-                                SiteEngagementScore::GetDecayPeriodInDays()));
-
-  double decayed_score = initial_score -
-                         kLessPeriodsThanNeededToDecayMaxScore *
-                             SiteEngagementScore::GetDecayPoints();
-  EXPECT_EQ(decayed_score, score_.Score());
-
-  // Now add some points.
-  score_.AddPoints(SiteEngagementScore::GetNavigationPoints());
-  EXPECT_EQ(decayed_score + SiteEngagementScore::GetNavigationPoints(),
-            score_.Score());
-}
-
-// Test that going back in time is handled properly.
-TEST_F(SiteEngagementScoreTest, GoBackInTime) {
-  base::Time current_day = GetReferenceTime();
-
-  test_clock_.SetNow(current_day);
-  for (int i = 0; i < kMoreAccumulationsThanNeededToMaxDailyEngagement; ++i)
-    score_.AddPoints(SiteEngagementScore::GetNavigationPoints());
-
-  EXPECT_EQ(SiteEngagementScore::GetMaxPointsPerDay(), score_.Score());
-
-  // Adding to the score on an earlier date should be treated like another day,
-  // and should not cause any decay.
-  test_clock_.SetNow(current_day - base::TimeDelta::FromDays(
-                                       kMorePeriodsThanNeededToDecayMaxScore *
-                                       SiteEngagementScore::GetDecayPoints()));
-  for (int i = 0; i < kMoreAccumulationsThanNeededToMaxDailyEngagement; ++i) {
-    score_.AddPoints(SiteEngagementScore::GetNavigationPoints());
-    double day_score =
-        std::min(SiteEngagementScore::GetMaxPointsPerDay(),
-                 (i + 1) * SiteEngagementScore::GetNavigationPoints());
-    EXPECT_EQ(day_score + SiteEngagementScore::GetMaxPointsPerDay(),
-              score_.Score());
-  }
-
-  EXPECT_EQ(2 * SiteEngagementScore::GetMaxPointsPerDay(), score_.Score());
-}
-
-// Test that scores are read / written correctly from / to empty score
-// dictionaries.
-TEST_F(SiteEngagementScoreTest, EmptyDictionary) {
-  base::DictionaryValue dict;
-  TestScoreInitializesAndUpdates(&dict, 0, 0, base::Time());
-}
-
-// Test that scores are read / written correctly from / to partially empty
-// score dictionaries.
-TEST_F(SiteEngagementScoreTest, PartiallyEmptyDictionary) {
-  base::DictionaryValue dict;
-  dict.SetDouble(SiteEngagementScore::kPointsAddedTodayKey, 2);
-
-  TestScoreInitializesAndUpdates(&dict, 0, 2, base::Time());
-}
-
-// Test that scores are read / written correctly from / to populated score
-// dictionaries.
-TEST_F(SiteEngagementScoreTest, PopulatedDictionary) {
-  base::DictionaryValue dict;
-  dict.SetDouble(SiteEngagementScore::kRawScoreKey, 1);
-  dict.SetDouble(SiteEngagementScore::kPointsAddedTodayKey, 2);
-  dict.SetDouble(SiteEngagementScore::kLastEngagementTimeKey,
-                  GetReferenceTime().ToInternalValue());
-
-  TestScoreInitializesAndUpdates(&dict, 1, 2, GetReferenceTime());
-}
-
-// Ensure bonus engagement is awarded for the first engagement of a day.
-TEST_F(SiteEngagementScoreTest, FirstDailyEngagementBonus) {
-  SetFirstDailyEngagementPointsForTesting(0.5);
-
-  SiteEngagementScore score1(&test_clock_);
-  SiteEngagementScore score2(&test_clock_);
-  base::Time current_day = GetReferenceTime();
-
-  test_clock_.SetNow(current_day);
-
-  // The first engagement event gets the bonus.
-  score1.AddPoints(0.5);
-  EXPECT_EQ(1.0, score1.Score());
-
-  // Subsequent events do not.
-  score1.AddPoints(0.5);
-  EXPECT_EQ(1.5, score1.Score());
-
-  // Bonuses are awarded independently between scores.
-  score2.AddPoints(1.0);
-  EXPECT_EQ(1.5, score2.Score());
-  score2.AddPoints(1.0);
-  EXPECT_EQ(2.5, score2.Score());
-
-  test_clock_.SetNow(current_day + base::TimeDelta::FromDays(1));
-
-  // The first event for the next day gets the bonus.
-  score1.AddPoints(0.5);
-  EXPECT_EQ(2.5, score1.Score());
-
-  // Subsequent events do not.
-  score1.AddPoints(0.5);
-  EXPECT_EQ(3.0, score1.Score());
-
-  score2.AddPoints(1.0);
-  EXPECT_EQ(4.0, score2.Score());
-  score2.AddPoints(1.0);
-  EXPECT_EQ(5.0, score2.Score());
-}
-
-// Test that resetting a score has the correct properties.
-TEST_F(SiteEngagementScoreTest, Reset) {
-  base::Time current_day = GetReferenceTime();
-
-  test_clock_.SetNow(current_day);
-  score_.AddPoints(SiteEngagementScore::GetNavigationPoints());
-  EXPECT_EQ(SiteEngagementScore::GetNavigationPoints(), score_.Score());
-
-  current_day += base::TimeDelta::FromDays(7);
-  test_clock_.SetNow(current_day);
-
-  score_.Reset(20.0, nullptr);
-  EXPECT_DOUBLE_EQ(20.0, score_.Score());
-  EXPECT_DOUBLE_EQ(0, score_.points_added_today_);
-  EXPECT_EQ(current_day, score_.last_engagement_time_);
-  EXPECT_TRUE(score_.last_shortcut_launch_time_.is_null());
-
-  // Adding points after the reset should work as normal.
-  score_.AddPoints(5);
-  EXPECT_EQ(25.0, score_.Score());
-
-  // The decay should happen one decay period from the current time.
-  test_clock_.SetNow(current_day +
-                     base::TimeDelta::FromDays(
-                         SiteEngagementScore::GetDecayPeriodInDays() + 1));
-  EXPECT_EQ(25.0 - SiteEngagementScore::GetDecayPoints(), score_.Score());
-
-  // Ensure that manually setting a time works as expected.
-  score_.AddPoints(5);
-  test_clock_.SetNow(GetReferenceTime());
-  base::Time now = test_clock_.Now();
-  score_.Reset(10.0, &now);
-
-  EXPECT_DOUBLE_EQ(10.0, score_.Score());
-  EXPECT_DOUBLE_EQ(0, score_.points_added_today_);
-  EXPECT_EQ(now, score_.last_engagement_time_);
-  EXPECT_TRUE(score_.last_shortcut_launch_time_.is_null());
-
-  score_.set_last_shortcut_launch_time(test_clock_.Now());
-  test_clock_.SetNow(GetReferenceTime() + base::TimeDelta::FromDays(3));
-  now = test_clock_.Now();
-  score_.Reset(15.0, &now);
-
-  // 5 bonus from the last shortcut launch.
-  EXPECT_DOUBLE_EQ(20.0, score_.Score());
-  EXPECT_DOUBLE_EQ(0, score_.points_added_today_);
-  EXPECT_EQ(now, score_.last_engagement_time_);
-  EXPECT_EQ(now, score_.last_shortcut_launch_time_);
-}
-
 class SiteEngagementServiceTest : public ChromeRenderViewHostTestHarness {
  public:
   void SetUp() override {
     ChromeRenderViewHostTestHarness::SetUp();
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     g_temp_history_dir = temp_dir_.path();
     HistoryServiceFactory::GetInstance()->SetTestingFactory(
         profile(), &BuildTestHistoryService);
     SiteEngagementScore::SetParamValuesForTesting();
   }
@@ skipping 22 matching lines @@
         ->TestDidNavigate(web_contents()->GetMainFrame(), 1, pending_id, true,
                           url, transition);
     EXPECT_EQ(prev_score, service->GetScore(url));
   }
 
  private:
   base::ScopedTempDir temp_dir_;
 };
 
 TEST_F(SiteEngagementServiceTest, GetMedianEngagement) {
-  SiteEngagementService* service =
-      SiteEngagementServiceFactory::GetForProfile(profile());
+  SiteEngagementService* service = SiteEngagementService::Get(profile());
   ASSERT_TRUE(service);
 
   GURL url1("http://www.google.com/");
   GURL url2("https://www.google.com/");
   GURL url3("https://drive.google.com/");
   GURL url4("https://maps.google.com/");
   GURL url5("https://youtube.com/");
   GURL url6("https://images.google.com/");
 
   {
@@ skipping 45 matching lines @@
     std::map<GURL, double> score_map = service->GetScoreMap();
     EXPECT_TRUE(6 == score_map.size());
     EXPECT_DOUBLE_EQ(1.9, service->GetMedianEngagement(score_map));
   }
 }
 
 // Tests that the Site Engagement service is hooked up properly to navigations
 // by performing two navigations and checking the engagement score increases
 // both times.
 TEST_F(SiteEngagementServiceTest, ScoreIncrementsOnPageRequest) {
-  SiteEngagementService* service =
-      SiteEngagementServiceFactory::GetForProfile(profile());
+  SiteEngagementService* service = SiteEngagementService::Get(profile());
   ASSERT_TRUE(service);
 
   // Create the helper manually since it isn't present when a tab isn't created.
-  SiteEngagementHelper::CreateForWebContents(web_contents());
+  SiteEngagementService::Helper::CreateForWebContents(web_contents());
 
   GURL url("http://www.google.com/");
   EXPECT_EQ(0, service->GetScore(url));
   NavigateWithTransitionAndExpectHigherScore(service, url,
                                              ui::PAGE_TRANSITION_TYPED);
   NavigateWithTransitionAndExpectHigherScore(service, url,
                                              ui::PAGE_TRANSITION_AUTO_BOOKMARK);
 }
 
 // Expect that site engagement scores for several sites are correctly
 // aggregated during navigation events.
 TEST_F(SiteEngagementServiceTest, GetTotalNavigationPoints) {
-  SiteEngagementService* service =
-      SiteEngagementServiceFactory::GetForProfile(profile());
+  SiteEngagementService* service = SiteEngagementService::Get(profile());
   ASSERT_TRUE(service);
 
   // The https and http versions of www.google.com should be separate.
   GURL url1("https://www.google.com/");
   GURL url2("http://www.google.com/");
   GURL url3("http://drive.google.com/");
 
   EXPECT_EQ(0, service->GetScore(url1));
   EXPECT_EQ(0, service->GetScore(url2));
   EXPECT_EQ(0, service->GetScore(url3));
@@ skipping 15 matching lines @@
   EXPECT_EQ(0.5, service->GetScore(url3));
   EXPECT_EQ(2.5, service->GetTotalEngagementPoints());
 
   service->HandleNavigation(url1, ui::PAGE_TRANSITION_GENERATED);
   service->HandleNavigation(url1, ui::PAGE_TRANSITION_TYPED);
   EXPECT_EQ(1.5, service->GetScore(url1));
   EXPECT_EQ(3.5, service->GetTotalEngagementPoints());
 }
 
 TEST_F(SiteEngagementServiceTest, GetTotalUserInputPoints) {
-  SiteEngagementService* service =
-      SiteEngagementServiceFactory::GetForProfile(profile());
+  SiteEngagementService* service = SiteEngagementService::Get(profile());
   ASSERT_TRUE(service);
 
   // The https and http versions of www.google.com should be separate.
   GURL url1("https://www.google.com/");
   GURL url2("http://www.google.com/");
   GURL url3("http://drive.google.com/");
 
   EXPECT_EQ(0, service->GetScore(url1));
   EXPECT_EQ(0, service->GetScore(url2));
   EXPECT_EQ(0, service->GetScore(url3));
@@ skipping 51 matching lines @@
       SiteEngagementMetrics::kEngagementTypeHistogram,
       SiteEngagementMetrics::ENGAGEMENT_WEBAPP_SHORTCUT_LAUNCH, 1);
 
   service->AddPoints(url1, 2.0);
   service->AddPoints(url2, 2.0);
   clock->SetNow(current_day);
   service->SetLastShortcutLaunchTime(url2);
 
   histograms.ExpectTotalCount(
       SiteEngagementMetrics::kDaysSinceLastShortcutLaunchHistogram, 1);
-  histograms.ExpectTotalCount(
-      SiteEngagementMetrics::kEngagementTypeHistogram, 4);
+  histograms.ExpectTotalCount(SiteEngagementMetrics::kEngagementTypeHistogram,
+                              4);
   histograms.ExpectBucketCount(
       SiteEngagementMetrics::kEngagementTypeHistogram,
       SiteEngagementMetrics::ENGAGEMENT_WEBAPP_SHORTCUT_LAUNCH, 2);
   histograms.ExpectBucketCount(
       SiteEngagementMetrics::kEngagementTypeHistogram,
       SiteEngagementMetrics::ENGAGEMENT_FIRST_DAILY_ENGAGEMENT, 2);
 
   EXPECT_DOUBLE_EQ(2.0, service->GetScore(url1));
   EXPECT_DOUBLE_EQ(7.0, service->GetScore(url2));
 
@@ skipping 352 matching lines @@
 
     score_map = service->GetScoreMap();
     EXPECT_EQ(0u, score_map.size());
     EXPECT_EQ(0, service->GetScore(url1));
   }
 }
 
 TEST_F(SiteEngagementServiceTest, NavigationAccumulation) {
   GURL url("https://www.google.com/");
 
-  SiteEngagementService* service =
-      SiteEngagementServiceFactory::GetForProfile(profile());
+  SiteEngagementService* service = SiteEngagementService::Get(profile());
   ASSERT_TRUE(service);
 
   // Create the helper manually since it isn't present when a tab isn't created.
-  SiteEngagementHelper::CreateForWebContents(web_contents());
+  SiteEngagementService::Helper::CreateForWebContents(web_contents());
 
   // Only direct navigation should trigger engagement.
   NavigateWithTransitionAndExpectHigherScore(service, url,
                                              ui::PAGE_TRANSITION_TYPED);
   NavigateWithTransitionAndExpectHigherScore(service, url,
                                              ui::PAGE_TRANSITION_GENERATED);
   NavigateWithTransitionAndExpectHigherScore(service, url,
                                              ui::PAGE_TRANSITION_AUTO_BOOKMARK);
   NavigateWithTransitionAndExpectHigherScore(
       service, url, ui::PAGE_TRANSITION_KEYWORD_GENERATED);
@@ skipping 343 matching lines @@
                                0, 2);
 
   // Add more points and ensure no more samples are present.
   service->AddPoints(origin1, 0.01);
   service->AddPoints(origin2, 0.01);
   histograms.ExpectTotalCount(SiteEngagementMetrics::kScoreDecayedFromHistogram,
                               4);
   histograms.ExpectTotalCount(SiteEngagementMetrics::kScoreDecayedToHistogram,
                               4);
 }