Connect Mojo budget_service to BudgetManager implementation of Reserve.

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/metrics/histogram_macros.h"
 #include "base/time/clock.h"
 #include "base/time/default_clock.h"
 #include "chrome/browser/budget_service/budget.pb.h"
@@ skipping 47 matching lines @@
 
 void BudgetDatabase::GetBudgetDetails(const url::Origin& origin,
                                       const GetBudgetCallback& callback) {
   SyncCache(origin,
             base::Bind(&BudgetDatabase::GetBudgetAfterSync,
                        weak_ptr_factory_.GetWeakPtr(), origin, callback));
 }
 
 void BudgetDatabase::SpendBudget(const url::Origin& origin,
                                  double amount,
-                                 const StoreBudgetCallback& callback) {
+                                 const SpendBudgetCallback& 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) {
@@ skipping 11 matching lines @@
     return total;
 
   const BudgetInfo& info = iter->second;
   for (const BudgetChunk& chunk : info.chunks)
     total += chunk.amount;
   return total;
 }
 
 void BudgetDatabase::AddToCache(
     const url::Origin& origin,
-    const AddToCacheCallback& callback,
+    const CacheCallback& 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 the database read failed or there's nothing to add, just return.
   if (!success || !budget_proto) {
     callback.Run(success);
     return;
   }
 
   // If there were two simultaneous loads, don't overwrite the cache value,
   // which might have been updated after the previous load.
   if (IsCached(origin)) {
     callback.Run(success);
     return;
@@ skipping 50 matching lines @@
   }
 
   DCHECK_EQ(0, total);
 
   callback.Run(blink::mojom::BudgetServiceErrorType::NONE,
                std::move(predictions));
 }
 
 void BudgetDatabase::SpendBudgetAfterSync(const url::Origin& origin,
                                           double amount,
-                                          const StoreBudgetCallback& callback,
+                                          const SpendBudgetCallback& callback,
                                           bool success) {
   if (!success) {
-    callback.Run(false /* success */);
+    callback.Run(blink::mojom::BudgetServiceErrorType::DATABASE_ERROR,
+                 false /* success */);
     return;
   }
 
   // Get the current SES score, to generate UMA.
   SiteEngagementService* service = SiteEngagementService::Get(profile_);
   double score = service->GetScore(GURL(origin.Serialize()));
 
   // Walk the list of budget chunks to see if the origin has enough budget.
   double total = 0;
   BudgetInfo& info = budget_map_[origin];
   for (const BudgetChunk& chunk : info.chunks)
     total += chunk.amount;
 
   if (total < amount) {
     UMA_HISTOGRAM_COUNTS_100("PushMessaging.SESForNoBudgetOrigin", score);
-    callback.Run(false /* success */);
+    callback.Run(blink::mojom::BudgetServiceErrorType::NONE,
+                 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;
     }
     bill -= iter->amount;
     iter = info.chunks.erase(iter);
   }
 
   // There should have been enough budget to cover the entire bill.
   DCHECK_EQ(0, bill);
 
   // Now that the cache is updated, write the data to the database.
-  // TODO(harkness): Consider adding a second parameter to the callback so the
-  // caller can distinguish between not enough budget and a failed database
-  // write.
+  WriteCachedValuesToDatabase(
+      origin, base::Bind(&BudgetDatabase::SpendBudgetAfterWrite,
+                         weak_ptr_factory_.GetWeakPtr(), callback));
+}
+
+// This converts the bool value which is returned from the database to a Mojo
+// error type.
+void BudgetDatabase::SpendBudgetAfterWrite(const SpendBudgetCallback& callback,
+                                           bool write_successful) {
   // TODO(harkness): If the database write fails, the cache will be out of sync
   // with the database. Consider ways to mitigate this.
-  WriteCachedValuesToDatabase(origin, callback);
+  if (!write_successful) {
+    callback.Run(blink::mojom::BudgetServiceErrorType::DATABASE_ERROR,
+                 false /* success */);
+    return;
+  }
+  callback.Run(blink::mojom::BudgetServiceErrorType::NONE, true /* success */);
 }
 
 void BudgetDatabase::WriteCachedValuesToDatabase(
     const url::Origin& origin,
     const StoreBudgetCallback& callback) {
   // Create the data structures that are passed to the ProtoDatabase.
   std::unique_ptr<
       leveldb_proto::ProtoDatabase<budget_service::Budget>::KeyEntryVector>
       entries(new leveldb_proto::ProtoDatabase<
               budget_service::Budget>::KeyEntryVector());
@@ skipping 17 matching lines @@
   } else {
     // If the origin doesn't exist in the cache, this is a remove operation.
     keys_to_remove->push_back(origin.Serialize());
   }
 
   // Send the updates to the database.
   db_->UpdateEntries(std::move(entries), std::move(keys_to_remove), callback);
 }
 
 void BudgetDatabase::SyncCache(const url::Origin& origin,
-                               const SyncCacheCallback& callback) {
+                               const CacheCallback& callback) {
   // If the origin isn't already cached, add it to the cache.
   if (!IsCached(origin)) {
-    AddToCacheCallback add_callback =
+    CacheCallback add_callback =
         base::Bind(&BudgetDatabase::SyncLoadedCache,
                    weak_ptr_factory_.GetWeakPtr(), origin, callback);
     db_->GetEntry(origin.Serialize(), base::Bind(&BudgetDatabase::AddToCache,
                                                  weak_ptr_factory_.GetWeakPtr(),
                                                  origin, add_callback));
     return;
   }
   SyncLoadedCache(origin, callback, true /* success */);
 }
 
 void BudgetDatabase::SyncLoadedCache(const url::Origin& origin,
-                                     const SyncCacheCallback& callback,
+                                     const CacheCallback& 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.
@@ skipping 63 matching lines @@
           clock_->Now() - base::TimeDelta::FromHours(kBudgetDurationInHours)) {
     budget_map_.erase(origin);
     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;
 }