Add GetTotalEngagementPoints to SiteEngagementService.

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 "base/command_line.h"
 #include "base/test/simple_test_clock.h"
 #include "base/values.h"
 #include "chrome/browser/engagement/site_engagement_helper.h"
 #include "chrome/browser/engagement/site_engagement_service.h"
 #include "chrome/browser/engagement/site_engagement_service_factory.h"
@@ skipping 44 matching lines @@
   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* settings_dict,
+      base::DictionaryValue* score_dict,
       double expected_raw_score,
       double expected_points_added_today,
       base::Time expected_last_engagement_time) {
-    SiteEngagementScore initial_score(&test_clock_, *settings_dict);
+    SiteEngagementScore initial_score(&test_clock_, *score_dict);
     VerifyScore(initial_score, expected_raw_score, expected_points_added_today,
                 expected_last_engagement_time);
 
-    // Updating the settings dict should return false, as the score shouldn't
+    // Updating the score dict should return false, as the score shouldn't
     // have changed at this point.
-    EXPECT_FALSE(initial_score.UpdateSettings(settings_dict));
+    EXPECT_FALSE(initial_score.UpdateScoreDict(score_dict));
 
-    // Update the score to new values and verify it updates the settings 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.UpdateSettings(settings_dict));
-    SiteEngagementScore updated_score(&test_clock_, *settings_dict);
+    EXPECT_TRUE(initial_score.UpdateScoreDict(score_dict));
+    SiteEngagementScore updated_score(&test_clock_, *score_dict);
     VerifyScore(updated_score, 5, 10, different_day);
   }
 
   base::SimpleTestClock test_clock_;
   SiteEngagementScore score_;
 };
 
 // Navigate many times on the same day. Ensure each time the score goes up by
 // kNavigationPoints, but not more than kMaxPointsPerDay.
 TEST_F(SiteEngagementScoreTest, NavigateOnSameDay) {
@@ skipping 179 matching lines @@
     double day_score =
         std::min(SiteEngagementScore::kMaxPointsPerDay,
                  (i + 1) * SiteEngagementScore::kNavigationPoints);
     EXPECT_EQ(day_score + SiteEngagementScore::kMaxPointsPerDay,
               score_.Score());
   }
 
   EXPECT_EQ(2 * SiteEngagementScore::kMaxPointsPerDay, score_.Score());
 }
 
-// Test that scores are read / written correctly from / to empty settings
+// 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
-// settings dictionaries.
+// 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 settings
+// 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());
 }
 
-using SiteEngagementServiceTest = BrowserWithTestWindowTest;
+
+class SiteEngagementServiceTest : public BrowserWithTestWindowTest {
+ public:
+  SiteEngagementServiceTest() {}
+
+  void SetUp() override {
+    BrowserWithTestWindowTest::SetUp();
+    base::CommandLine::ForCurrentProcess()->AppendSwitch(
+        switches::kEnableSiteEngagementService);
+  }
+};
+
 
 // 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) {
-  base::CommandLine::ForCurrentProcess()->AppendSwitch(
-      switches::kEnableSiteEngagementService);
-
   SiteEngagementService* service =
       SiteEngagementServiceFactory::GetForProfile(profile());
   DCHECK(service);
 
   GURL url("http://www.google.com/");
 
   AddTab(browser(), GURL("about:blank"));
   EXPECT_EQ(0, service->GetScore(url));
   int prev_score = service->GetScore(url);
 
   NavigateAndCommitActiveTab(url);
   EXPECT_LT(prev_score, service->GetScore(url));
   prev_score = service->GetScore(url);
 
   NavigateAndCommitActiveTab(url);
   EXPECT_LT(prev_score, service->GetScore(url));
 }
+
+// Expect that site engagement scores for several sites are correctly aggregated
+// by GetTotalEngagementPoints().
+TEST_F(SiteEngagementServiceTest, GetTotalEngagementPoints) {
+  SiteEngagementService* service =
+      SiteEngagementServiceFactory::GetForProfile(profile());
+  DCHECK(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));
+
+  service->HandleNavigation(url1);
+  EXPECT_EQ(1, service->GetScore(url1));
+  EXPECT_EQ(1, service->GetTotalEngagementPoints());
+
+  service->HandleNavigation(url2);
+  service->HandleNavigation(url2);
+  EXPECT_EQ(2, service->GetScore(url2));
+  EXPECT_EQ(3, service->GetTotalEngagementPoints());
+
+  service->HandleNavigation(url3);
+  EXPECT_EQ(1, service->GetScore(url3));
+  EXPECT_EQ(4, service->GetTotalEngagementPoints());
+
+  service->HandleNavigation(url1);
+  service->HandleNavigation(url1);
+  EXPECT_EQ(3, service->GetScore(url1));
+  EXPECT_EQ(6, service->GetTotalEngagementPoints());
+}