Make BackgroundBudgetService calls asynchronous.

chrome/browser/budget_service/background_budget_service.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/budget_service/background_budget_service.h"
 
 #include <stdint.h>
 
 #include "base/callback.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/clock.h"
 #include "base/time/default_clock.h"
 #include "base/time/time.h"
 #include "chrome/browser/engagement/site_engagement_score.h"
 #include "chrome/browser/engagement/site_engagement_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/scoped_user_pref_update.h"
+#include "content/public/browser/browser_thread.h"
+
+using content::BrowserThread;
 
 namespace {
 
 constexpr char kSeparator = '#';
 
 // Calculate the ratio of the different components of a budget with respect
 // to a maximum time period of 10 days = 864000.0 seconds.
 constexpr double kSecondsToAccumulate = 864000.0;
 
 bool GetBudgetDataFromPrefs(Profile* profile,
@@ skipping 67 matching lines @@
 double BackgroundBudgetService::GetCost(CostType type) {
   switch (type) {
     case CostType::SILENT_PUSH:
       return 2.0;
       // No default case.
   }
   NOTREACHED();
   return SiteEngagementScore::kMaxPoints + 1.0;
 }
 
-double BackgroundBudgetService::GetBudget(const GURL& origin) {
+void BackgroundBudgetService::GetBudget(const GURL& origin,
+                                        const GetBudgetCallback& callback) {
   DCHECK_EQ(origin, origin.GetOrigin());
 
   // Get the current SES score, which we'll use to set a new budget.
   SiteEngagementService* service = SiteEngagementService::Get(profile_);
   double ses_score = service->GetScore(origin);
 
   // Get the last used budget data. This is a triple of last calculated time,
   // budget at that time, and Site Engagement Score (ses) at that time.
   double old_budget = 0.0, old_ses = 0.0, last_updated_msec = 0.0;
   if (!GetBudgetDataFromPrefs(profile_, origin, &old_budget, &old_ses,
                               &last_updated_msec)) {
     // If there is no stored data or the data can't be parsed, just return the
     // SES.
-    return ses_score;
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                            base::Bind(callback, ses_score));
+    return;
   }
 
   base::Time now = clock_->Now();
   base::TimeDelta elapsed = now - base::Time::FromDoubleT(last_updated_msec);
 
   // The user can set their clock backwards, so if the last updated time is in
   // the future, don't update the budget based on elapsed time. Eventually the
   // clock will reach the future, and the budget calculations will catch up.
   // TODO(harkness): Consider what to do if the clock jumps forward by a
   // significant amount.
-  if (elapsed.InMicroseconds() < 0)
-    return old_budget;
+  if (elapsed.InMicroseconds() < 0) {
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                            base::Bind(callback, old_budget));
+    return;
+  }
 
   // For each time period that elapses, calculate the carryover ratio as the
   // ratio of time remaining in our max period to the total period.
   // The carryover component is then the old budget multiplied by the ratio.
   double carryover_ratio = std::max(
       0.0,
       ((kSecondsToAccumulate - elapsed.InSeconds()) / kSecondsToAccumulate));
   double budget_carryover = old_budget * carryover_ratio;
 
   // The ses component is an average of the last ses score used for budget
   // calculation and the current ses score.
   // The ses average is them multiplied by the ratio of time elapsed to the
   // total period.
   double ses_ratio =
       std::min(1.0, (elapsed.InSeconds() / kSecondsToAccumulate));
   double ses_component = (old_ses + ses_score) / 2 * ses_ratio;
 
   // Budget recalculation consists of a budget carryover component, which
   // rewards sites that don't use all their budgets every day, and a ses
   // component, which gives extra budget to sites that have a high ses score.
   double budget = budget_carryover + ses_component;
   DCHECK_GE(budget, 0.0);
 
-  return budget;
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(callback, budget));
 }
 
-void BackgroundBudgetService::StoreBudget(const GURL& origin, double budget) {
+void BackgroundBudgetService::StoreBudget(const GURL& origin,
+                                          double budget,
+                                          const base::Closure& closure) {
   DCHECK_EQ(origin, origin.GetOrigin());
   DCHECK_GE(budget, 0.0);
   DCHECK_LE(budget, SiteEngagementService::GetMaxPoints());
 
   // Get the current SES score to write into the prefs with the new budget.
   SiteEngagementService* service = SiteEngagementService::Get(profile_);
   double ses_score = service->GetScore(origin);
 
   base::Time time = clock_->Now();
   SetBudgetDataInPrefs(profile_, origin, time.ToDoubleT(), budget, ses_score);
+
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(closure));
 }
 
 // Override the default clock with the specified clock. Only used for testing.
 void BackgroundBudgetService::SetClockForTesting(
     std::unique_ptr<base::Clock> clock) {
   clock_ = std::move(clock);
 }