Plumb site engagement to the renderer process.

chrome/browser/engagement/site_engagement_service.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 <stddef.h>
 
 #include <algorithm>
 #include <utility>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_util.h"
 #include "base/time/clock.h"
 #include "base/time/default_clock.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/banners/app_banner_settings_helper.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/engagement/site_engagement_eviction_policy.h"
+#include "chrome/browser/engagement/site_engagement_helper.h"
 #include "chrome/browser/engagement/site_engagement_metrics.h"
 #include "chrome/browser/engagement/site_engagement_score.h"
 #include "chrome/browser/engagement/site_engagement_service_factory.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/content_settings/core/common/content_settings_pattern.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
+#include "content/public/common/associated_interface_provider.h"
 #include "url/gurl.h"
 
 namespace {
 
 const int FOUR_WEEKS_IN_DAYS = 28;
 
 // Global bool to ensure we only update the parameters from variations once.
 bool g_updated_from_variations = false;
 
 // Length of time between metrics logging.
@@ skipping 69 matching lines @@
   }
 }
 
 SiteEngagementService::~SiteEngagementService() {
   history::HistoryService* history = HistoryServiceFactory::GetForProfile(
       profile_, ServiceAccessType::IMPLICIT_ACCESS);
   if (history)
     history->RemoveObserver(this);
 }
 
-SiteEngagementService::EngagementLevel
+blink::mojom::EngagementLevel
 SiteEngagementService::GetEngagementLevel(const GURL& url) const {
-  DCHECK_LT(SiteEngagementScore::GetMediumEngagementBoundary(),
-            SiteEngagementScore::GetHighEngagementBoundary());
-  double score = GetScore(url);
-  if (score == 0)
-    return ENGAGEMENT_LEVEL_NONE;
+  if (IsLastEngagementStale())
+    CleanupEngagementScores(true);
 
-  if (score < SiteEngagementScore::GetMediumEngagementBoundary())
-    return ENGAGEMENT_LEVEL_LOW;
-
-  if (score < SiteEngagementScore::GetHighEngagementBoundary())
-    return ENGAGEMENT_LEVEL_MEDIUM;
-
-  if (score < SiteEngagementScore::kMaxPoints)
-    return ENGAGEMENT_LEVEL_HIGH;
-
-  return ENGAGEMENT_LEVEL_MAX;
+  return CreateEngagementScore(url).GetEngagementLevel();

[benwells, 2016/12/09 06:11:23]

It looks like every time something calls CreateEngagementScore it has to have
previously checked if a cleanup is needed. That feels a bit error-prone, is
there a way to make it more robust?

[dominickn, 2016/12/13 06:27:37]

Not quite: OriginsWithMaxDailyEngagement,
GetCountsAndLastVisitForOriginsComplete, and ResetScoreForURL,
SetLastShortcutLaunchTime and CleanupEngagementScores itself all call
CreateEngagementScore without needing to check if a cleanup is needed. We only
need to check for a cleanup if we're about to use the score externally or add
points internally.

[benwells, 2016/12/14 06:17:53]

OK. If it was me I'd try to find a way to clean this up. I think it is tricky
and undiscoverable, and likely to break in future. But it's orthogonal to this
CL.

 }
 
 std::map<GURL, double> SiteEngagementService::GetScoreMap() const {
   HostContentSettingsMap* settings_map =
       HostContentSettingsMapFactory::GetForProfile(profile_);
   std::unique_ptr<ContentSettingsForOneType> engagement_settings =
       GetEngagementContentSettings(settings_map);
 
   std::map<GURL, double> score_map;
   for (const auto& site : *engagement_settings) {
     GURL origin(site.primary_pattern.ToString());
     if (!origin.is_valid())
       continue;
 
     score_map[origin] = GetScore(origin);
   }
 
   return score_map;
 }
 
 bool SiteEngagementService::IsBootstrapped() const {
   return GetTotalEngagementPoints() >=
          SiteEngagementScore::GetBootstrapPoints();
 }
 
-bool SiteEngagementService::IsEngagementAtLeast(const GURL& url,
-                                                EngagementLevel level) const {
+bool SiteEngagementService::IsEngagementAtLeast(
+    const GURL& url,
+    blink::mojom::EngagementLevel level) const {
   DCHECK_LT(SiteEngagementScore::GetMediumEngagementBoundary(),
             SiteEngagementScore::GetHighEngagementBoundary());
   double score = GetScore(url);
   switch (level) {
-    case ENGAGEMENT_LEVEL_NONE:
+    case blink::mojom::EngagementLevel::NONE:
       return true;
-    case ENGAGEMENT_LEVEL_LOW:
+    case blink::mojom::EngagementLevel::MINIMAL:
       return score > 0;
-    case ENGAGEMENT_LEVEL_MEDIUM:
+    case blink::mojom::EngagementLevel::LOW:
+      return score >= 1;
+    case blink::mojom::EngagementLevel::MEDIUM:
       return score >= SiteEngagementScore::GetMediumEngagementBoundary();
-    case ENGAGEMENT_LEVEL_HIGH:
+    case blink::mojom::EngagementLevel::HIGH:
       return score >= SiteEngagementScore::GetHighEngagementBoundary();
-    case ENGAGEMENT_LEVEL_MAX:
+    case blink::mojom::EngagementLevel::MAX:
       return score == SiteEngagementScore::kMaxPoints;
   }
   NOTREACHED();
   return false;
 }
 
 void SiteEngagementService::AddObserver(SiteEngagementObserver* observer) {
   observer_list_.AddObserver(observer);
 }
 
@@ skipping 18 matching lines @@
     SiteEngagementMetrics::RecordDaysSinceLastShortcutLaunch(
         std::max(0, (now - last_launch).InDays()));
   }
   SiteEngagementMetrics::RecordEngagement(
       SiteEngagementMetrics::ENGAGEMENT_WEBAPP_SHORTCUT_LAUNCH);
 
   score.set_last_shortcut_launch_time(now);
   score.Commit();
 }
 
+void SiteEngagementService::HelperCreated(
+    SiteEngagementService::Helper* helper) {
+  helpers_.insert(helper);
+}
+
+void SiteEngagementService::HelperDeleted(
+    SiteEngagementService::Helper* helper) {
+  helpers_.erase(helper);
+}
+
 double SiteEngagementService::GetScore(const GURL& url) const {
   // Ensure that if engagement is stale, we clean things up before fetching the
   // score.
   if (IsLastEngagementStale())
     CleanupEngagementScores(true);
 
   return CreateEngagementScore(url).GetScore();
 }
 
 double SiteEngagementService::GetTotalEngagementPoints() const {
@@ skipping 20 matching lines @@
   if (points == 0)
     return;
 
   // Trigger a cleanup and date adjustment if it has been a substantial length
   // of time since *any* engagement was recorded by the service. This will
   // ensure that we do not decay scores when the user did not use the browser.
   if (IsLastEngagementStale())
     CleanupEngagementScores(true);
 
   SiteEngagementScore score = CreateEngagementScore(url);
+  blink::mojom::EngagementLevel old_level = score.GetEngagementLevel();
+
   score.AddPoints(points);
   score.Commit();
 
   SetLastEngagementTime(score.last_engagement_time());
+
+  blink::mojom::EngagementLevel new_level = score.GetEngagementLevel();
+  if (old_level != new_level)
+    SendLevelChangeToHelpers(url, new_level);
 }
 
 void SiteEngagementService::AfterStartupTask() {
   // Check if we need to reset last engagement times on startup - we want to
   // avoid doing this in AddPoints() if possible. It is still necessary to check
   // in AddPoints for people who never restart Chrome, but leave it open and
   // their computer on standby.
   CleanupEngagementScores(IsLastEngagementStale());
   RecordMetrics();
 }
@@ skipping 201 matching lines @@
     return;
 
   SiteEngagementMetrics::RecordEngagement(type);
   AddPoints(url, SiteEngagementScore::GetUserInputPoints());
 
   RecordMetrics();
   for (SiteEngagementObserver& observer : observer_list_)
     observer.OnEngagementIncreased(web_contents, url, GetScore(url));
 }
 
+void SiteEngagementService::SendLevelChangeToHelpers(
+    const GURL& url,
+    blink::mojom::EngagementLevel level) {
+  for (SiteEngagementService::Helper* helper : helpers_)
+    helper->OnEngagementLevelChanged(url, level);
+}
+
 bool SiteEngagementService::IsLastEngagementStale() const {
   // Only happens on first run when no engagement has ever been recorded.
   base::Time last_engagement_time = GetLastEngagementTime();
   if (last_engagement_time.is_null())
     return false;
 
   // Stale is either too *far* back, or any amount *forward* in time. This could
   // occur due to a changed clock, or extended non-use of the browser.
   return (clock_->Now() - last_engagement_time) >= GetStalePeriod() ||
          (clock_->Now() < last_engagement_time);
@@ skipping 119 matching lines @@
     if (!engagement_score.last_shortcut_launch_time().is_null() &&
         engagement_score.last_shortcut_launch_time() > last_visit) {
       engagement_score.set_last_shortcut_launch_time(last_visit);
     }
 
     engagement_score.Commit();
   }
 
   SetLastEngagementTime(now);
 }