Switch to standard integer types in content/browser/.

content/browser/quota/quota_temporary_storage_evictor_unittest.cc

 // Copyright 2014 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 <stdint.h>
+
 #include <list>
 #include <map>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "content/public/test/mock_storage_client.h"
 #include "storage/browser/quota/quota_manager.h"
 #include "storage/browser/quota/quota_temporary_storage_evictor.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using storage::QuotaTemporaryStorageEvictor;
 using storage::StorageType;
@@ skipping 13 matching lines @@
         error_on_evict_origin_data_(false),
         error_on_get_usage_and_quota_(false) {}
 
   void EvictOriginData(const GURL& origin,
                        StorageType type,
                        const EvictOriginDataCallback& callback) override {
     if (error_on_evict_origin_data_) {
       callback.Run(storage::kQuotaErrorInvalidModification);
       return;
     }
-    int64 origin_usage = EnsureOriginRemoved(origin);
+    int64_t origin_usage = EnsureOriginRemoved(origin);
     if (origin_usage >= 0)
       available_space_ += origin_usage;
     callback.Run(storage::kQuotaStatusOk);
   }
 
   void GetUsageAndQuotaForEviction(
       const UsageAndQuotaCallback& callback) override {
     if (error_on_get_usage_and_quota_) {
       callback.Run(storage::kQuotaErrorInvalidAccess, UsageAndQuota());
       return;
     }
     if (!task_for_get_usage_and_quota_.is_null())
       task_for_get_usage_and_quota_.Run();
     UsageAndQuota quota_and_usage(-1, GetUsage(), quota_, available_space_);
     callback.Run(storage::kQuotaStatusOk, quota_and_usage);
   }
 
   void GetEvictionOrigin(StorageType type,
                          const std::set<GURL>& exceptions,
-                         int64 global_quota,
+                         int64_t global_quota,
                          const storage::GetOriginCallback& callback) override {
     if (origin_order_.empty())
       callback.Run(GURL());
     else
       callback.Run(GURL(origin_order_.front()));
   }
 
-  int64 GetUsage() const {
-    int64 total_usage = 0;
-    for (std::map<GURL, int64>::const_iterator p = origins_.begin();
-         p != origins_.end();
-         ++p)
+  int64_t GetUsage() const {
+    int64_t total_usage = 0;
+    for (std::map<GURL, int64_t>::const_iterator p = origins_.begin();
+         p != origins_.end(); ++p)
       total_usage += p->second;
     return total_usage;
   }
 
-  void set_quota(int64 quota) {
-    quota_ = quota;
-  }
-  void set_available_space(int64 available_space) {
+  void set_quota(int64_t quota) { quota_ = quota; }
+  void set_available_space(int64_t available_space) {
     available_space_ = available_space;
   }
   void set_task_for_get_usage_and_quota(const base::Closure& task) {
     task_for_get_usage_and_quota_= task;
   }
   void set_error_on_evict_origin_data(bool error_on_evict_origin_data) {
     error_on_evict_origin_data_ = error_on_evict_origin_data;
   }
   void set_error_on_get_usage_and_quota(bool error_on_get_usage_and_quota) {
     error_on_get_usage_and_quota_ = error_on_get_usage_and_quota;
   }
 
   // Simulates an access to |origin|.  It reorders the internal LRU list.
   // It internally uses AddOrigin().
   void AccessOrigin(const GURL& origin) {
-    std::map<GURL, int64>::iterator found = origins_.find(origin);
+    std::map<GURL, int64_t>::iterator found = origins_.find(origin);
     EXPECT_TRUE(origins_.end() != found);
     AddOrigin(origin, found->second);
   }
 
   // Simulates adding or overwriting the |origin| to the internal origin set
   // with the |usage|.  It also adds or moves the |origin| to the end of the
   // LRU list.
-  void AddOrigin(const GURL& origin, int64 usage) {
+  void AddOrigin(const GURL& origin, int64_t usage) {
     EnsureOriginRemoved(origin);
     origin_order_.push_back(origin);
     origins_[origin] = usage;
   }
 
  private:
-  int64 EnsureOriginRemoved(const GURL& origin) {
-    int64 origin_usage;
+  int64_t EnsureOriginRemoved(const GURL& origin) {
+    int64_t origin_usage;
     if (origins_.find(origin) == origins_.end())
       return -1;
     else
       origin_usage = origins_[origin];
 
     origins_.erase(origin);
     origin_order_.remove(origin);
     return origin_usage;
   }
 
-  int64 quota_;
-  int64 available_space_;
+  int64_t quota_;
+  int64_t available_space_;
   std::list<GURL> origin_order_;
-  std::map<GURL, int64> origins_;
+  std::map<GURL, int64_t> origins_;
   bool error_on_evict_origin_data_;
   bool error_on_get_usage_and_quota_;
 
   base::Closure task_for_get_usage_and_quota_;
 };
 
 }  // namespace
 
 class QuotaTemporaryStorageEvictorTest : public testing::Test {
  public:
   QuotaTemporaryStorageEvictorTest()
       : num_get_usage_and_quota_for_eviction_(0),
         weak_factory_(this) {}
 
   void SetUp() override {
     quota_eviction_handler_.reset(new MockQuotaEvictionHandler(this));
 
     // Run multiple evictions in a single RunUntilIdle() when interval_ms == 0
     temporary_storage_evictor_.reset(new QuotaTemporaryStorageEvictor(
         quota_eviction_handler_.get(), 0));
   }
 
   void TearDown() override {
     temporary_storage_evictor_.reset();
     quota_eviction_handler_.reset();
     base::RunLoop().RunUntilIdle();
   }
 
   void TaskForRepeatedEvictionTest(
-      const std::pair<GURL, int64>& origin_to_be_added,
+      const std::pair<GURL, int64_t>& origin_to_be_added,
       const GURL& origin_to_be_accessed,
       int expected_usage_after_first,
       int expected_usage_after_second) {
     EXPECT_GE(4, num_get_usage_and_quota_for_eviction_);
     switch (num_get_usage_and_quota_for_eviction_) {
     case 2:
       EXPECT_EQ(expected_usage_after_first,
                 quota_eviction_handler()->GetUsage());
       if (!origin_to_be_added.first.is_empty())
         quota_eviction_handler()->AddOrigin(origin_to_be_added.first,
@@ skipping 25 matching lines @@
   }
 
   void set_repeated_eviction(bool repeated_eviction) const {
     return temporary_storage_evictor_->set_repeated_eviction(repeated_eviction);
   }
 
   int num_get_usage_and_quota_for_eviction() const {
     return num_get_usage_and_quota_for_eviction_;
   }
 
-  int64 default_min_available_disk_space_to_start_eviction() const {
+  int64_t default_min_available_disk_space_to_start_eviction() const {
     return 1000 * 1000 * 500;
   }
 
-  void set_min_available_disk_space_to_start_eviction(int64 value) const {
+  void set_min_available_disk_space_to_start_eviction(int64_t value) const {
     temporary_storage_evictor_->set_min_available_disk_space_to_start_eviction(
         value);
   }
 
   void reset_min_available_disk_space_to_start_eviction() const {
     temporary_storage_evictor_->
         reset_min_available_disk_space_to_start_eviction();
   }
 
   base::MessageLoop message_loop_;
@@ skipping 40 matching lines @@
   EXPECT_EQ(450 + 400, quota_eviction_handler()->GetUsage());
 
   EXPECT_EQ(0, statistics().num_errors_on_evicting_origin);
   EXPECT_EQ(0, statistics().num_errors_on_getting_usage_and_quota);
   EXPECT_EQ(2, statistics().num_evicted_origins);
   EXPECT_EQ(1, statistics().num_eviction_rounds);
   EXPECT_EQ(0, statistics().num_skipped_eviction_rounds);
 }
 
 TEST_F(QuotaTemporaryStorageEvictorTest, RepeatedEvictionTest) {
-  const int64 a_size = 400;
-  const int64 b_size = 150;
-  const int64 c_size = 120;
-  const int64 d_size = 292;
-  const int64 initial_total_size = a_size + b_size + c_size + d_size;
-  const int64 e_size = 275;
+  const int64_t a_size = 400;
+  const int64_t b_size = 150;
+  const int64_t c_size = 120;
+  const int64_t d_size = 292;
+  const int64_t initial_total_size = a_size + b_size + c_size + d_size;
+  const int64_t e_size = 275;
 
   quota_eviction_handler()->AddOrigin(GURL("http://www.d.com"), d_size);
   quota_eviction_handler()->AddOrigin(GURL("http://www.c.com"), c_size);
   quota_eviction_handler()->AddOrigin(GURL("http://www.b.com"), b_size);
   quota_eviction_handler()->AddOrigin(GURL("http://www.a.com"), a_size);
   quota_eviction_handler()->set_quota(1000);
   quota_eviction_handler()->set_available_space(1000000000);
   quota_eviction_handler()->set_task_for_get_usage_and_quota(
       base::Bind(&QuotaTemporaryStorageEvictorTest::TaskForRepeatedEvictionTest,
                  weak_factory_.GetWeakPtr(),
                  std::make_pair(GURL("http://www.e.com"), e_size), GURL(),
                  initial_total_size - d_size,
                  initial_total_size - d_size + e_size - c_size));
   EXPECT_EQ(initial_total_size, quota_eviction_handler()->GetUsage());
   temporary_storage_evictor()->Start();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(initial_total_size - d_size + e_size - c_size - b_size,
             quota_eviction_handler()->GetUsage());
   EXPECT_EQ(5, num_get_usage_and_quota_for_eviction());
 
   EXPECT_EQ(0, statistics().num_errors_on_evicting_origin);
   EXPECT_EQ(0, statistics().num_errors_on_getting_usage_and_quota);
   EXPECT_EQ(3, statistics().num_evicted_origins);
   EXPECT_EQ(2, statistics().num_eviction_rounds);
   EXPECT_EQ(0, statistics().num_skipped_eviction_rounds);
 }
 
 TEST_F(QuotaTemporaryStorageEvictorTest, RepeatedEvictionSkippedTest) {
-  const int64 a_size = 400;
-  const int64 b_size = 150;
-  const int64 c_size = 120;
-  const int64 d_size = 292;
-  const int64 initial_total_size = a_size + b_size + c_size + d_size;
+  const int64_t a_size = 400;
+  const int64_t b_size = 150;
+  const int64_t c_size = 120;
+  const int64_t d_size = 292;
+  const int64_t initial_total_size = a_size + b_size + c_size + d_size;
 
   quota_eviction_handler()->AddOrigin(GURL("http://www.d.com"), d_size);
   quota_eviction_handler()->AddOrigin(GURL("http://www.c.com"), c_size);
   quota_eviction_handler()->AddOrigin(GURL("http://www.b.com"), b_size);
   quota_eviction_handler()->AddOrigin(GURL("http://www.a.com"), a_size);
   quota_eviction_handler()->set_quota(1000);
   quota_eviction_handler()->set_available_space(1000000000);
   quota_eviction_handler()->set_task_for_get_usage_and_quota(
       base::Bind(&QuotaTemporaryStorageEvictorTest::TaskForRepeatedEvictionTest,
                  weak_factory_.GetWeakPtr(), std::make_pair(GURL(), 0), GURL(),
                  initial_total_size - d_size, initial_total_size - d_size));
   EXPECT_EQ(initial_total_size, quota_eviction_handler()->GetUsage());
   set_repeated_eviction(true);
   temporary_storage_evictor()->Start();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(initial_total_size - d_size, quota_eviction_handler()->GetUsage());
   EXPECT_EQ(4, num_get_usage_and_quota_for_eviction());
 
   EXPECT_EQ(0, statistics().num_errors_on_evicting_origin);
   EXPECT_EQ(0, statistics().num_errors_on_getting_usage_and_quota);
   EXPECT_EQ(1, statistics().num_evicted_origins);
   EXPECT_EQ(3, statistics().num_eviction_rounds);
   EXPECT_EQ(2, statistics().num_skipped_eviction_rounds);
 }
 
 TEST_F(QuotaTemporaryStorageEvictorTest, RepeatedEvictionWithAccessOriginTest) {
-  const int64 a_size = 400;
-  const int64 b_size = 150;
-  const int64 c_size = 120;
-  const int64 d_size = 292;
-  const int64 initial_total_size = a_size + b_size + c_size + d_size;
-  const int64 e_size = 275;
+  const int64_t a_size = 400;
+  const int64_t b_size = 150;
+  const int64_t c_size = 120;
+  const int64_t d_size = 292;
+  const int64_t initial_total_size = a_size + b_size + c_size + d_size;
+  const int64_t e_size = 275;
 
   quota_eviction_handler()->AddOrigin(GURL("http://www.d.com"), d_size);
   quota_eviction_handler()->AddOrigin(GURL("http://www.c.com"), c_size);
   quota_eviction_handler()->AddOrigin(GURL("http://www.b.com"), b_size);
   quota_eviction_handler()->AddOrigin(GURL("http://www.a.com"), a_size);
   quota_eviction_handler()->set_quota(1000);
   quota_eviction_handler()->set_available_space(1000000000);
   quota_eviction_handler()->set_task_for_get_usage_and_quota(
       base::Bind(&QuotaTemporaryStorageEvictorTest::TaskForRepeatedEvictionTest,
                  weak_factory_.GetWeakPtr(),
@@ skipping 52 matching lines @@
   EXPECT_EQ(150 + 300, quota_eviction_handler()->GetUsage());
 
   EXPECT_EQ(0, statistics().num_errors_on_evicting_origin);
   EXPECT_EQ(0, statistics().num_errors_on_getting_usage_and_quota);
   EXPECT_EQ(2, statistics().num_evicted_origins);
   EXPECT_EQ(1, statistics().num_eviction_rounds);
   EXPECT_EQ(0, statistics().num_skipped_eviction_rounds);
 }
 
 }  // namespace content