Small cleanup of SiteEngagementService.

chrome/browser/engagement/site_engagement_score_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/engagement/site_engagement_score.h"
 
 #include <utility>
 
 #include "base/macros.h"
 #include "base/test/simple_test_clock.h"
@@ skipping 22 matching lines @@
   exploded_reference_time.second = 0;
   exploded_reference_time.millisecond = 0;
 
   return base::Time::FromLocalExploded(exploded_reference_time);
 }
 
 }  // namespace
 
 class SiteEngagementScoreTest : public testing::Test {
  public:
-  SiteEngagementScoreTest() : score_(&test_clock_) {}
+  SiteEngagementScoreTest() : score_(&test_clock_, nullptr) {}
 
   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,
+      std::unique_ptr<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);
+    std::unique_ptr<base::DictionaryValue> copy(score_dict->DeepCopy());
+    SiteEngagementScore initial_score(&test_clock_, std::move(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));
+    EXPECT_FALSE(initial_score.UpdateScoreDict(copy.get()));
 
     // 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);
+    EXPECT_TRUE(initial_score.UpdateScoreDict(copy.get()));
+    SiteEngagementScore updated_score(&test_clock_, std::move(copy));
     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_;
@@ skipping 188 matching lines @@
     EXPECT_EQ(day_score + SiteEngagementScore::GetMaxPointsPerDay(),
               score_.GetScore());
   }
 
   EXPECT_EQ(2 * SiteEngagementScore::GetMaxPointsPerDay(), score_.GetScore());
 }
 
 // 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());
+  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+  TestScoreInitializesAndUpdates(std::move(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);
+  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+  dict->SetDouble(SiteEngagementScore::kPointsAddedTodayKey, 2);
 
-  TestScoreInitializesAndUpdates(&dict, 0, 2, base::Time());
+  TestScoreInitializesAndUpdates(std::move(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());
+  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+  dict->SetDouble(SiteEngagementScore::kRawScoreKey, 1);
+  dict->SetDouble(SiteEngagementScore::kPointsAddedTodayKey, 2);
+  dict->SetDouble(SiteEngagementScore::kLastEngagementTimeKey,
+                  GetReferenceTime().ToInternalValue());
 
-  TestScoreInitializesAndUpdates(&dict, 1, 2, GetReferenceTime());
+  TestScoreInitializesAndUpdates(std::move(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_);
+  SiteEngagementScore score1(&test_clock_,
+                             std::unique_ptr<base::DictionaryValue>());
+  SiteEngagementScore score2(&test_clock_,
+                             std::unique_ptr<base::DictionaryValue>());
   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.GetScore());
 
   // Subsequent events do not.
   score1.AddPoints(0.5);
@@ skipping 25 matching lines @@
 TEST_F(SiteEngagementScoreTest, Reset) {
   base::Time current_day = GetReferenceTime();
 
   test_clock_.SetNow(current_day);
   score_.AddPoints(SiteEngagementScore::GetNavigationPoints());
   EXPECT_EQ(SiteEngagementScore::GetNavigationPoints(), score_.GetScore());
 
   current_day += base::TimeDelta::FromDays(7);
   test_clock_.SetNow(current_day);
 
-  score_.Reset(20.0, nullptr);
+  score_.Reset(20.0, current_day);
   EXPECT_DOUBLE_EQ(20.0, score_.GetScore());
   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_.GetScore());
 
   // 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_.GetScore());
 
   // 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);
+  score_.Reset(10.0, now);
 
   EXPECT_DOUBLE_EQ(10.0, score_.GetScore());
   EXPECT_DOUBLE_EQ(0, score_.points_added_today_);
   EXPECT_EQ(now, score_.last_engagement_time_);
   EXPECT_TRUE(score_.last_shortcut_launch_time_.is_null());
 
+  base::Time old_now = test_clock_.Now();
+
   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);
+  score_.Reset(15.0, now);
 
   // 5 bonus from the last shortcut launch.
   EXPECT_DOUBLE_EQ(20.0, score_.GetScore());
   EXPECT_DOUBLE_EQ(0, score_.points_added_today_);
   EXPECT_EQ(now, score_.last_engagement_time_);
-  EXPECT_EQ(now, score_.last_shortcut_launch_time_);
+  EXPECT_EQ(old_now, score_.last_shortcut_launch_time_);
 }