Implement an observer interface for the site engagement service.

chrome/browser/engagement/site_engagement_service.h

 // 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.
 
 #ifndef CHROME_BROWSER_ENGAGEMENT_SITE_ENGAGEMENT_SERVICE_H_
 #define CHROME_BROWSER_ENGAGEMENT_SITE_ENGAGEMENT_SERVICE_H_
 
 #include <map>
 #include <memory>
 #include <set>
 
+#include "base/callback_forward.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
 #include "chrome/browser/engagement/site_engagement_metrics.h"
 #include "components/history/core/browser/history_service_observer.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "ui/base/page_transition_types.h"
 
 namespace base {
@@ skipping 29 matching lines @@
 // such as rejecting permission prompts or not responding to notifications, will
 // decrease the site engagement score.
 class SiteEngagementService : public KeyedService,
                               public history::HistoryServiceObserver,
                               public SiteEngagementScoreProvider {
  public:
   // WebContentsObserver that detects engagement triggering events and notifies
   // the service of them.
   class Helper;
 
+  // Callback used by the site engagement service to signal that a given origin
+  // has reached a given engagement score. When invoked, the callback will be
+  // passed the score for |url|'s origin at the time of invocation, and the URL
+  // which led to the engagement reaching that score (or the origin if the score
+  // was already at the requested level).
+  using EngagementCallback = base::Callback<void(const GURL&, double)>;
+  using EngagementCallbacks = std::vector<EngagementCallback>;
+
   enum EngagementLevel {
     ENGAGEMENT_LEVEL_NONE,
     ENGAGEMENT_LEVEL_LOW,
     ENGAGEMENT_LEVEL_MEDIUM,
     ENGAGEMENT_LEVEL_HIGH,
     ENGAGEMENT_LEVEL_MAX,
   };
 
   // The name of the site engagement variation field trial.
   static const char kEngagementParams[];
@@ skipping 19 matching lines @@
   std::map<GURL, double> GetScoreMap() const;
 
   // Returns whether the engagement service has enough data to make meaningful
   // decisions. Clients should avoid using engagement in their heuristic until
   // this is true.
   bool IsBootstrapped();
 
   // Returns whether |url| has at least the given |level| of engagement.
   bool IsEngagementAtLeast(const GURL& url, EngagementLevel level) const;
 
+  // Register |callback| to be run on the UI thread when the engagement for
+  // |url|'s origin reaches |level| or |score|. Callbacks for origins which have

[calamity, 2016/05/19 03:28:22]

It's not obvious that this only happens when engagement goes above the specified
score/level.

[dominickn, 2016/05/19 04:36:15]

I've made this comment more explicit - it's equal to or greater than.

+  // already reached the requested score will be dispatched as soon as they are
+  // registered. Callers are responsible for ensuring that |callback| is safe to
+  // run at any time.
+  void RegisterCallback(const EngagementCallback& callback,
+                        const GURL& url,
+                        EngagementLevel level);
+  void RegisterCallback(const EngagementCallback& callback,
+                        const GURL& url,
+                        double score);
+
   // Resets the engagement score |url| to |score|, clearing daily limits.
   void ResetScoreForURL(const GURL& url, double score);
 
   // Update the last time |url| was opened from an installed shortcut to be
   // clock_->Now().
   void SetLastShortcutLaunchTime(const GURL& url);
 
   // Overridden from SiteEngagementScoreProvider.
   double GetScore(const GURL& url) const override;
   double GetTotalEngagementPoints() const override;
 
  private:
+  // Wrapping struct for callbacks.
+  struct EngagementCallbackWrapper {
+    EngagementCallback* callback;
+    GURL origin;
+    double score;
+  };
+
   FRIEND_TEST_ALL_PREFIXES(SiteEngagementServiceTest, CheckHistograms);
   FRIEND_TEST_ALL_PREFIXES(SiteEngagementServiceTest, CleanupEngagementScores);
   FRIEND_TEST_ALL_PREFIXES(SiteEngagementServiceTest, ClearHistoryForURLs);
   FRIEND_TEST_ALL_PREFIXES(SiteEngagementServiceTest, GetMedianEngagement);
   FRIEND_TEST_ALL_PREFIXES(SiteEngagementServiceTest, GetTotalNavigationPoints);
   FRIEND_TEST_ALL_PREFIXES(SiteEngagementServiceTest, GetTotalUserInputPoints);
   FRIEND_TEST_ALL_PREFIXES(SiteEngagementServiceTest, LastShortcutLaunch);
   FRIEND_TEST_ALL_PREFIXES(SiteEngagementServiceTest,
                            CleanupOriginsOnHistoryDeletion);
   FRIEND_TEST_ALL_PREFIXES(SiteEngagementServiceTest, IsBootstrapped);
   FRIEND_TEST_ALL_PREFIXES(SiteEngagementServiceTest, EngagementLevel);
+  FRIEND_TEST_ALL_PREFIXES(SiteEngagementServiceTest, RegisterCallbacks);
   FRIEND_TEST_ALL_PREFIXES(SiteEngagementServiceTest, ScoreDecayHistograms);
   FRIEND_TEST_ALL_PREFIXES(AppBannerSettingsHelperTest, SiteEngagementTrigger);
 
   // Only used in tests.
   SiteEngagementService(Profile* profile, std::unique_ptr<base::Clock> clock);
 
   // Adds the specified number of points to the given origin, respecting the
   // maximum limits for the day and overall.
   void AddPoints(const GURL& url, double points);
 
   // Post startup tasks: cleaning up origins which have decayed to 0, and
   // logging UMA statistics.
   void AfterStartupTask();
   void CleanupEngagementScores();
   void RecordMetrics();
 
   // Returns the median engagement score of all recorded origins.
   double GetMedianEngagement(const std::map<GURL, double>& score_map) const;
 
+  // Returns the minimum engagement score corresponding to |level|.
+  double GetScoreForEngagementLevel(EngagementLevel level) const;
+
   // Update the engagement score of the origin matching |url| for media playing.
   // The points awarded are discounted if the media is being played in a non-
   // visible tab.
   void HandleMediaPlaying(const GURL& url, bool is_hidden);
 
   // Update the engagement score of the origin matching |url| for navigation.
   void HandleNavigation(const GURL& url, ui::PageTransition transition);
 
   // Update the engagement score of the origin matching |url| for time-on-site,
   // based on user input.
@@ skipping 13 matching lines @@
   int OriginsWithMaxEngagement(const std::map<GURL, double>& score_map) const;
 
   // Callback for the history service when it is asked for a map of origins to
   // how many URLs corresponding to that origin remain in history.
   void GetCountsAndLastVisitForOriginsComplete(
     history::HistoryService* history_service,
     const std::multiset<GURL>& deleted_url_origins,
     bool expired,
     const history::OriginCountAndLastVisitMap& remaining_origin_counts);
 
+  // Runs any callbacks in |engagement_callbacks_| which have been registered to
+  // listen to |url|'s origin reaching at least |score| engagement.
+  void ProcessCallbacks(const GURL& url, double score);
+
+  // Dispatches |callback| to be run on the UI thread, and deletes it once it
+  // has finished running.
+  void PostCallback(const EngagementCallback* callback,
+                    const GURL& url,
+                    double score);
+
   // Resets the engagement score for |url| to |score|, and sets the last
   // engagement time and last shortcut launch time (if it is non-null) to
   // |updated_time|. Clears daily limits.
   void ResetScoreAndAccessTimesForURL(const GURL& url,
                                       double score,
                                       const base::Time* updated_time);
 
+  // Runs |callback| and deletes it once it has finished execution.
+  void RunAndDeleteCallback(const EngagementCallback* callback,
+                            const GURL& origin,
+                            double score) const;
+
   Profile* profile_;
 
   // The clock used to vend times.
   std::unique_ptr<base::Clock> clock_;
 
   // Metrics are recorded at non-incognito browser startup, and then
   // approximately once per hour thereafter. Store the local time at which
   // metrics were previously uploaded: the first event which affects any
   // origin's engagement score after an hour has elapsed triggers the next
   // upload.
   base::Time last_metrics_time_;
 
+  // A list of callbacks, registered with an origin and an engagement score.
+  // Once a callback is dispatched, its wrapper will be removed from the list.
+  std::vector<EngagementCallbackWrapper> engagement_callbacks_;
+
   base::WeakPtrFactory<SiteEngagementService> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SiteEngagementService);
 };
 
 #endif  // CHROME_BROWSER_ENGAGEMENT_SITE_ENGAGEMENT_SERVICE_H_