Cleanup budget_database based on evolving API.

chrome/browser/budget_service/budget_database_unittest.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/run_loop.h"
 #include "base/test/simple_test_clock.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/budget_service/budget.pb.h"
@@ skipping 36 matching lines @@
     db_.AddBudget(origin, amount,
                   base::Bind(&BudgetDatabaseTest::AddBudgetComplete,
                              base::Unretained(this), run_loop.QuitClosure()));
     run_loop.Run();
     return success_;
   }
 
   void GetBudgetDetailsComplete(
       base::Closure run_loop_closure,
       bool success,
-      double debt,
       const BudgetDatabase::BudgetExpectation& expectation) {
     success_ = success;
-    debt_ = debt;
     expectation_ = expectation;
     run_loop_closure.Run();
   }
 
   // Get the full set of budget expectations for the origin.
   void GetBudgetDetails() {
     base::RunLoop run_loop;
     db_.GetBudgetDetails(
         GURL(kTestOrigin),
         base::Bind(&BudgetDatabaseTest::GetBudgetDetailsComplete,
@@ skipping 17 matching lines @@
   bool IsCached(const GURL& origin) { return db_.IsCached(origin); }
 
  protected:
   bool success_;
 
  private:
   content::TestBrowserThreadBundle thread_bundle_;
   std::unique_ptr<budget_service::Budget> budget_;
   TestingProfile profile_;
   BudgetDatabase db_;
-  double debt_ = 0;
   BudgetDatabase::BudgetExpectation expectation_;
 };
 
 TEST_F(BudgetDatabaseTest, ReadAndWriteTest) {
   const GURL origin(kTestOrigin);
   base::SimpleTestClock* clock = SetClockForTesting();
   base::TimeDelta expiration(
       base::TimeDelta::FromHours(kDefaultExpirationInHours));
   base::Time starting_time = clock->Now();
   base::Time expiration_time = clock->Now() + expiration;
 
   // Add two budget chunks with different expirations (default expiration and
   // default expiration + 1 day).
   ASSERT_TRUE(AddBudget(origin, kDefaultBudget1));
   clock->Advance(base::TimeDelta::FromDays(1));
   ASSERT_TRUE(AddBudget(origin, kDefaultBudget2));
 
   // Get the budget.
   GetBudgetDetails();
 
   // Get the expectation and validate it.
   const auto& expected_value = expectation();
   ASSERT_TRUE(success_);
   ASSERT_EQ(3U, expected_value.size());
 
   // Make sure that the correct data is returned.
   auto iter = expected_value.begin();
 
   // First value should be [total_budget, now]
-  EXPECT_EQ(kDefaultBudget1 + kDefaultBudget2, iter->first);
-  EXPECT_EQ(clock->Now(), iter->second);
+  EXPECT_EQ(kDefaultBudget1 + kDefaultBudget2, iter->budget_at);
+  EXPECT_EQ(clock->Now(), iter->time);
 
   // The next value should be the budget after the first chunk expires.
   iter++;
-  EXPECT_EQ(kDefaultBudget2, iter->first);
-  EXPECT_EQ(expiration_time, iter->second);
+  EXPECT_EQ(kDefaultBudget2, iter->budget_at);
+  EXPECT_EQ(expiration_time, iter->time);
 
   // The final value gives the budget of 0.0 after the second chunk expires.
   expiration_time += base::TimeDelta::FromDays(1);
   iter++;
-  EXPECT_EQ(0, iter->first);
-  EXPECT_EQ(expiration_time, iter->second);
+  EXPECT_EQ(0, iter->budget_at);
+  EXPECT_EQ(expiration_time, iter->time);
 
   // Advance the time until the first chunk of budget should be expired.
   clock->SetNow(starting_time +
                 base::TimeDelta::FromHours(kDefaultExpirationInHours));
 
   // Get the new budget and check that kDefaultBudget1 has been removed.
   GetBudgetDetails();
   iter = expectation().begin();
   ASSERT_EQ(2U, expectation().size());
-  EXPECT_EQ(kDefaultBudget2, iter->first);
+  EXPECT_EQ(kDefaultBudget2, iter->budget_at);
   iter++;
-  EXPECT_EQ(0, iter->first);
+  EXPECT_EQ(0, iter->budget_at);
 
   // Advace the time until both chunks of budget should be expired.
   clock->SetNow(starting_time +
                 base::TimeDelta::FromHours(kDefaultExpirationInHours) +
                 base::TimeDelta::FromDays(1));
 
   GetBudgetDetails();
   iter = expectation().begin();
   ASSERT_EQ(1U, expectation().size());
-  EXPECT_EQ(0, iter->first);
+  EXPECT_EQ(0, iter->budget_at);
 
   // Now that the entire budget has expired, check that the entry in the map
   // has been removed.
   EXPECT_FALSE(IsCached(origin));
 }