Full hookup of BudgetManager interfaces to BudgetDatabase.

chrome/browser/budget_service/budget_database.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/budget_database.h"
 
-#include "base/containers/adapters.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/time/clock.h"
 #include "base/time/default_clock.h"
 #include "chrome/browser/budget_service/budget.pb.h"
 #include "chrome/browser/engagement/site_engagement_score.h"
 #include "chrome/browser/engagement/site_engagement_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "components/leveldb_proto/proto_database_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "url/gurl.h"
 
 using content::BrowserThread;
 
 namespace {
 
 // UMA are logged for the database with this string as part of the name.
 // They will be LevelDB.*.BudgetManager. Changes here should be synchronized
 // with histograms.xml.
 const char kDatabaseUMAName[] = "BudgetManager";
 
 // The default amount of time during which a budget will be valid.
-// This is 3 days = 72 hours.
-constexpr double kBudgetDurationInHours = 72;
+// This is 10 days = 240 hours.
+constexpr double kBudgetDurationInHours = 240;
 
 }  // namespace
 
 BudgetDatabase::BudgetInfo::BudgetInfo() {}
 
 BudgetDatabase::BudgetInfo::BudgetInfo(const BudgetInfo&& other)
     : last_engagement_award(other.last_engagement_award) {
   chunks = std::move(other.chunks);
 }
 
 BudgetDatabase::BudgetInfo::~BudgetInfo() {}
 
 BudgetDatabase::BudgetDatabase(
     Profile* profile,
     const base::FilePath& database_dir,
     const scoped_refptr<base::SequencedTaskRunner>& task_runner)
     : profile_(profile),
       db_(new leveldb_proto::ProtoDatabaseImpl<budget_service::Budget>(
           task_runner)),
       clock_(base::WrapUnique(new base::DefaultClock)),
       weak_ptr_factory_(this) {
   db_->Init(kDatabaseUMAName, database_dir,
             base::Bind(&BudgetDatabase::OnDatabaseInit,
                        weak_ptr_factory_.GetWeakPtr()));
 }
 
 BudgetDatabase::~BudgetDatabase() {}
 
-void BudgetDatabase::GetBudgetDetails(
-    const GURL& origin,
-    const GetBudgetDetailsCallback& callback) {
+void BudgetDatabase::GetBudgetDetails(const GURL& origin,
+                                      const GetBudgetCallback& callback) {
   DCHECK_EQ(origin.GetOrigin(), origin);
 
   SyncCache(origin,
             base::Bind(&BudgetDatabase::GetBudgetAfterSync,
                        weak_ptr_factory_.GetWeakPtr(), origin, callback));
 }
 
 void BudgetDatabase::SpendBudget(const GURL& origin,
                                  double amount,
                                  const StoreBudgetCallback& callback) {
   SyncCache(origin, base::Bind(&BudgetDatabase::SpendBudgetAfterSync,
                                weak_ptr_factory_.GetWeakPtr(), origin, amount,
                                callback));
 }
 
 void BudgetDatabase::SetClockForTesting(std::unique_ptr<base::Clock> clock) {
   clock_ = std::move(clock);
 }
 
 void BudgetDatabase::OnDatabaseInit(bool success) {
   // TODO(harkness): Consider caching the budget database now?
 }
 
 bool BudgetDatabase::IsCached(const GURL& origin) const {
   return budget_map_.find(origin.spec()) != budget_map_.end();
 }
 
+double BudgetDatabase::GetBudget(const GURL& origin) const {
+  double total = 0;
+  auto iter = budget_map_.find(origin.spec());
+  if (iter == budget_map_.end())
+    return total;
+
+  const BudgetInfo& info = iter->second;
+  for (const BudgetChunk& chunk : info.chunks)
+    total += chunk.amount;
+  return total;
+}
+
 void BudgetDatabase::AddToCache(
     const GURL& origin,
     const AddToCacheCallback& callback,
     bool success,
     std::unique_ptr<budget_service::Budget> budget_proto) {
   // If the database read failed, there's nothing to add to the cache.
   if (!success || !budget_proto) {
     callback.Run(success);
     return;
   }
@@ skipping 12 matching lines @@
     info.chunks.emplace_back(chunk.amount(),
                              base::Time::FromInternalValue(chunk.expiration()));
   }
 
   info.last_engagement_award =
       base::Time::FromInternalValue(budget_proto->engagement_last_updated());
 
   callback.Run(success);
 }
 
-void BudgetDatabase::GetBudgetAfterSync(
-    const GURL& origin,
-    const GetBudgetDetailsCallback& callback,
-    bool success) {
+void BudgetDatabase::GetBudgetAfterSync(const GURL& origin,
+                                        const GetBudgetCallback& callback,
+                                        bool success) {
+  mojo::Array<blink::mojom::BudgetStatePtr> predictions;
+
   // If the database wasn't able to read the information, return the
-  // failure and an empty BudgetPrediction.
+  // failure and an empty predictions array.
   if (!success) {
-    callback.Run(success, BudgetPrediction());
+    callback.Run(blink::mojom::BudgetServiceErrorType::DATABASE_ERROR,
+                 std::move(predictions));
     return;
   }
 
   // Now, build up the BudgetExpection. This is different from the format
   // in which the cache stores the data. The cache stores chunks of budget and
-  // when that budget expires. The BudgetPrediction describes a set of times
+  // when that budget expires. The mojo array describes a set of times
   // and the budget at those times.
-  BudgetPrediction prediction;
-  double total = 0;
+  double total = GetBudget(origin);
 
-  // Starting with the chunks that expire the farthest in the future, build up
-  // the budget predictions for those future times.
+  // Always add one entry at the front of the list for the total budget now.
+  blink::mojom::BudgetStatePtr prediction(blink::mojom::BudgetState::New());
+  prediction->budget_at = total;
+  prediction->time = clock_->Now().ToDoubleT();
+  predictions.push_back(std::move(prediction));
+
+  // Starting with the soonest expiring chunks, add entries for the
+  // expiration times going forward.
   const BudgetChunks& chunks = budget_map_[origin.spec()].chunks;
-  for (const auto& chunk : base::Reversed(chunks)) {
-    prediction.emplace_front(total, chunk.expiration);
-    total += chunk.amount;
+  for (const auto& chunk : chunks) {
+    blink::mojom::BudgetStatePtr prediction(blink::mojom::BudgetState::New());
+    total -= chunk.amount;
+    prediction->budget_at = total;
+    prediction->time = chunk.expiration.ToDoubleT();
+    predictions.push_back(std::move(prediction));
   }
 
-  // Always add one entry at the front of the list for the total budget now.
-  prediction.emplace_front(total, clock_->Now());
+  DCHECK_EQ(0, total);
 
-  callback.Run(true /* success */, prediction);
+  callback.Run(blink::mojom::BudgetServiceErrorType::NONE,
+               std::move(predictions));
 }
 
 void BudgetDatabase::SpendBudgetAfterSync(const GURL& origin,
                                           double amount,
                                           const StoreBudgetCallback& callback,
                                           bool success) {
   if (!success) {
     callback.Run(false /* success */);
     return;
   }
 
+  // Get the current SES score, to generate UMA.
+  SiteEngagementService* service = SiteEngagementService::Get(profile_);
+  double score = service->GetScore(origin);
+
   // Walk the list of budget chunks to see if the origin has enough budget.
   double total = 0;
   BudgetInfo& info = budget_map_[origin.spec()];
   for (const BudgetChunk& chunk : info.chunks)
     total += chunk.amount;
 
   if (total < amount) {
+    UMA_HISTOGRAM_COUNTS_100("PushMessaging.SESForNoBudgetOrigin", score);
     callback.Run(false /* success */);
     return;
+  } else if (total < amount * 2) {
+    UMA_HISTOGRAM_COUNTS_100("PushMessaging.SESForLowBudgetOrigin", score);
   }
 
   // Walk the chunks and remove enough budget to cover the needed amount.
   double bill = amount;
   for (auto iter = info.chunks.begin(); iter != info.chunks.end();) {
     if (iter->amount > bill) {
       iter->amount -= bill;
       bill = 0;
       break;
     }
@@ skipping 65 matching lines @@
 }
 
 void BudgetDatabase::SyncLoadedCache(const GURL& origin,
                                      const SyncCacheCallback& callback,
                                      bool success) {
   if (!success) {
     callback.Run(false /* success */);
     return;
   }
 
+  // Now, cleanup any expired budget chunks for the origin.
+  bool needs_write = CleanupExpiredBudget(origin);
+
   // Get the SES score and add engagement budget for the site.
   AddEngagementBudget(origin);
 
-  // Now, cleanup any expired budget chunks for the origin.
-  bool needs_write = CleanupExpiredBudget(origin);
-
   if (needs_write)
     WriteCachedValuesToDatabase(origin, callback);
   else
     callback.Run(success);
 }
 
 void BudgetDatabase::AddEngagementBudget(const GURL& origin) {
   // Get the current SES score, which we'll use to set a new budget.
   SiteEngagementService* service = SiteEngagementService::Get(profile_);
   double score = service->GetScore(origin);
@@ skipping 16 matching lines @@
   }
 
   // Update the last_engagement_award to the current time. If the origin wasn't
   // already in the map, this adds a new entry for it.
   budget_map_[origin.spec()].last_engagement_award = clock_->Now();
 
   // Add a new chunk of budget for the origin at the default expiration time.
   base::Time expiration =
       clock_->Now() + base::TimeDelta::FromHours(kBudgetDurationInHours);
   budget_map_[origin.spec()].chunks.emplace_back(ratio * score, expiration);
+
+  // Any time we award engagement budget, which is done at most once an hour
+  // whenever any budget action is taken, record the budget.
+  double budget = GetBudget(origin);
+  UMA_HISTOGRAM_COUNTS_100("PushMessaging.BackgroundBudget", budget);
 }
 
 // Cleans up budget in the cache. Relies on the caller eventually writing the
 // cache back to the database.
 bool BudgetDatabase::CleanupExpiredBudget(const GURL& origin) {
   if (!IsCached(origin))
     return false;
 
   base::Time now = clock_->Now();
   BudgetChunks& chunks = budget_map_[origin.spec()].chunks;
@@ skipping 10 matching lines @@
           clock_->Now() - base::TimeDelta::FromHours(kBudgetDurationInHours)) {
     budget_map_.erase(origin.spec());
     return true;
   }
 
   // Although some things may have expired, there are some chunks still valid.
   // Don't write to the DB now, write either when all chunks expire or when the
   // origin spends some budget.
   return false;
 }