Switch to standard integer types in content/browser/.

content/browser/quota/storage_monitor_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 <vector>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/public/test/mock_special_storage_policy.h"
 #include "content/public/test/mock_storage_client.h"
 #include "net/base/net_util.h"
 #include "storage/browser/quota/quota_manager.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
@@ skipping 50 matching lines @@
       : QuotaManager(false,
                      base::FilePath(),
                      base::ThreadTaskRunnerHandle::Get().get(),
                      base::ThreadTaskRunnerHandle::Get().get(),
                      special_storage_policy),
         callback_usage_(0),
         callback_quota_(0),
         callback_status_(kQuotaStatusOk),
         initialized_(false) {}
 
-  void SetCallbackParams(int64 usage, int64 quota, QuotaStatusCode status) {
+  void SetCallbackParams(int64_t usage, int64_t quota, QuotaStatusCode status) {
     initialized_ = true;
     callback_quota_ = quota;
     callback_usage_ = usage;
     callback_status_ = status;
   }
 
   void InvokeCallback() {
     delayed_callback_.Run(callback_status_, callback_usage_, callback_quota_);
   }
 
   void GetUsageAndQuotaForWebApps(
       const GURL& origin,
       StorageType type,
       const GetUsageAndQuotaCallback& callback) override {
     if (initialized_)
       callback.Run(callback_status_, callback_usage_, callback_quota_);
     else
       delayed_callback_ = callback;
   }
 
  protected:
   ~UsageMockQuotaManager() override {}
 
  private:
-  int64 callback_usage_;
-  int64 callback_quota_;
+  int64_t callback_usage_;
+  int64_t callback_quota_;
   QuotaStatusCode callback_status_;
   bool initialized_;
   GetUsageAndQuotaCallback delayed_callback_;
 };
 
 }  // namespace
 
 class StorageMonitorTestBase : public testing::Test {
  protected:
   void DispatchPendingEvents(StorageObserverList& observer_list) {
@@ skipping 202 matching lines @@
 // Tests for HostStorageObservers:
 
 typedef StorageTestWithManagerBase HostStorageObserversTest;
 
 // Verify that HostStorageObservers is initialized after the first usage change.
 TEST_F(HostStorageObserversTest, InitializeOnUsageChange) {
   StorageObserver::MonitorParams params(kStorageTypePersistent,
                                         GURL(kDefaultOrigin),
                                         base::TimeDelta::FromHours(1),
                                         false);
-  const int64 kUsage = 324554;
-  const int64 kQuota = 234354354;
+  const int64_t kUsage = 324554;
+  const int64_t kQuota = 234354354;
   quota_manager_->SetCallbackParams(kUsage, kQuota, kQuotaStatusOk);
 
   MockObserver mock_observer;
   HostStorageObservers host_observers(quota_manager_.get());
   host_observers.AddObserver(&mock_observer, params);
 
   // Verify that HostStorageObservers dispatches the first event correctly.
   StorageObserver::Event expected_event(params.filter, kUsage, kQuota);
   host_observers.NotifyUsageChange(params.filter, 87324);
   EXPECT_EQ(1, mock_observer.EventCount());
   EXPECT_EQ(expected_event, mock_observer.LastEvent());
   EXPECT_TRUE(host_observers.is_initialized());
 
   // Verify that HostStorageObservers handles subsequent usage changes
   // correctly.
-  const int64 kDelta = 2345;
+  const int64_t kDelta = 2345;
   expected_event.usage += kDelta;
   SetLastNotificationTime(host_observers, &mock_observer);
   host_observers.NotifyUsageChange(params.filter, kDelta);
   EXPECT_EQ(2, mock_observer.EventCount());
   EXPECT_EQ(expected_event, mock_observer.LastEvent());
 }
 
 // Verify that HostStorageObservers is initialized after the adding the first
 // observer that elected to receive the initial state.
 TEST_F(HostStorageObserversTest, InitializeOnObserver) {
-  const int64 kUsage = 74387;
-  const int64 kQuota = 92834743;
+  const int64_t kUsage = 74387;
+  const int64_t kQuota = 92834743;
   quota_manager_->SetCallbackParams(kUsage, kQuota, kQuotaStatusOk);
   HostStorageObservers host_observers(quota_manager_.get());
 
   // |host_observers| should not be initialized after the first observer is
   // added because it did not elect to receive the initial state.
   StorageObserver::MonitorParams params(kStorageTypePersistent,
                                         GURL(kDefaultOrigin),
                                         base::TimeDelta::FromHours(1),
                                         false);
   MockObserver mock_observer1;
   host_observers.AddObserver(&mock_observer1, params);
   EXPECT_FALSE(host_observers.is_initialized());
   EXPECT_EQ(0, mock_observer1.EventCount());
 
   // |host_observers| should be initialized after the second observer is
   // added.
   MockObserver mock_observer2;
   params.dispatch_initial_state = true;
   host_observers.AddObserver(&mock_observer2, params);
   StorageObserver::Event expected_event(params.filter, kUsage, kQuota);
   EXPECT_EQ(0, mock_observer1.EventCount());
   EXPECT_EQ(1, mock_observer2.EventCount());
   EXPECT_EQ(expected_event, mock_observer2.LastEvent());
   EXPECT_TRUE(host_observers.is_initialized());
   EXPECT_EQ(NULL, GetPendingEvent(host_observers));
   EXPECT_EQ(0, GetRequiredUpdatesCount(host_observers));
 
   // Verify that both observers will receive events after a usage change.
-  const int64 kDelta = 2345;
+  const int64_t kDelta = 2345;
   expected_event.usage += kDelta;
   SetLastNotificationTime(host_observers, &mock_observer2);
   host_observers.NotifyUsageChange(params.filter, kDelta);
   EXPECT_EQ(1, mock_observer1.EventCount());
   EXPECT_EQ(2, mock_observer2.EventCount());
   EXPECT_EQ(expected_event, mock_observer1.LastEvent());
   EXPECT_EQ(expected_event, mock_observer2.LastEvent());
   EXPECT_EQ(NULL, GetPendingEvent(host_observers));
   EXPECT_EQ(0, GetRequiredUpdatesCount(host_observers));
 
   // Verify that the addition of a third observer only causes an event to be
   // dispatched to the new observer.
   MockObserver mock_observer3;
   params.dispatch_initial_state = true;
   host_observers.AddObserver(&mock_observer3, params);
   EXPECT_EQ(1, mock_observer1.EventCount());
   EXPECT_EQ(2, mock_observer2.EventCount());
   EXPECT_EQ(1, mock_observer3.EventCount());
   EXPECT_EQ(expected_event, mock_observer3.LastEvent());
 }
 
 // Verify that negative usage and quota is changed to zero.
 TEST_F(HostStorageObserversTest, NegativeUsageAndQuota) {
   StorageObserver::MonitorParams params(kStorageTypePersistent,
                                         GURL(kDefaultOrigin),
                                         base::TimeDelta::FromHours(1),
                                         false);
-  const int64 kUsage = -324554;
-  const int64 kQuota = -234354354;
+  const int64_t kUsage = -324554;
+  const int64_t kQuota = -234354354;
   quota_manager_->SetCallbackParams(kUsage, kQuota, kQuotaStatusOk);
 
   MockObserver mock_observer;
   HostStorageObservers host_observers(quota_manager_.get());
   host_observers.AddObserver(&mock_observer, params);
 
   StorageObserver::Event expected_event(params.filter, 0, 0);
   host_observers.NotifyUsageChange(params.filter, -87324);
   EXPECT_EQ(expected_event, mock_observer.LastEvent());
 }
 
 // Verify that HostStorageObservers can recover from a bad initialization.
 TEST_F(HostStorageObserversTest, RecoverFromBadUsageInit) {
   StorageObserver::MonitorParams params(kStorageTypePersistent,
                                         GURL(kDefaultOrigin),
                                         base::TimeDelta::FromHours(1),
                                         false);
   MockObserver mock_observer;
   HostStorageObservers host_observers(quota_manager_.get());
   host_observers.AddObserver(&mock_observer, params);
 
   // Set up the quota manager to return an error status.
-  const int64 kUsage = 6656;
-  const int64 kQuota = 99585556;
+  const int64_t kUsage = 6656;
+  const int64_t kQuota = 99585556;
   quota_manager_->SetCallbackParams(kUsage, kQuota, kQuotaErrorNotSupported);
 
   // Verify that |host_observers| is not initialized and an event has not been
   // dispatched.
   host_observers.NotifyUsageChange(params.filter, 9438);
   EXPECT_EQ(0, mock_observer.EventCount());
   EXPECT_FALSE(host_observers.is_initialized());
   EXPECT_EQ(NULL, GetPendingEvent(host_observers));
   EXPECT_EQ(0, GetRequiredUpdatesCount(host_observers));
 
@@ skipping 20 matching lines @@
   // Trigger initialization. Leave the mock quota manager uninitialized so that
   // the callback is not invoked.
   host_observers.NotifyUsageChange(params.filter, 7645);
   EXPECT_EQ(0, mock_observer.EventCount());
   EXPECT_FALSE(host_observers.is_initialized());
   EXPECT_EQ(NULL, GetPendingEvent(host_observers));
   EXPECT_EQ(0, GetRequiredUpdatesCount(host_observers));
 
   // Simulate notifying |host_observers| of a usage change before initialization
   // is complete.
-  const int64 kUsage = 6656;
-  const int64 kQuota = 99585556;
-  const int64 kDelta = 327643;
+  const int64_t kUsage = 6656;
+  const int64_t kQuota = 99585556;
+  const int64_t kDelta = 327643;
   host_observers.NotifyUsageChange(params.filter, kDelta);
   EXPECT_EQ(0, mock_observer.EventCount());
   EXPECT_FALSE(host_observers.is_initialized());
   EXPECT_EQ(NULL, GetPendingEvent(host_observers));
   EXPECT_EQ(0, GetRequiredUpdatesCount(host_observers));
 
   // Simulate an asynchronous callback from QuotaManager.
   quota_manager_->SetCallbackParams(kUsage, kQuota, kQuotaStatusOk);
   quota_manager_->InvokeCallback();
   StorageObserver::Event expected_event(params.filter, kUsage + kDelta, kQuota);
@@ skipping 117 matching lines @@
 
 // Test adding storage observers.
 TEST_F(StorageMonitorTest, AddObservers) {
   // Verify that the observers are added correctly.
   CheckObserverCount(2, 3);
 }
 
 // Test dispatching events to storage observers.
 TEST_F(StorageMonitorTest, EventDispatch) {
   // Verify dispatch of events.
-  const int64 kUsage = 5325;
-  const int64 kQuota = 903845;
+  const int64_t kUsage = 5325;
+  const int64_t kQuota = 903845;
   quota_manager_->SetCallbackParams(kUsage, kQuota, kQuotaStatusOk);
   storage_monitor_->NotifyUsageChange(params1_.filter, 9048543);
 
   StorageObserver::Event expected_event(params1_.filter, kUsage, kQuota);
   EXPECT_EQ(1, mock_observer1_.EventCount());
   EXPECT_EQ(1, mock_observer2_.EventCount());
   EXPECT_EQ(0, mock_observer3_.EventCount());
   EXPECT_EQ(expected_event, mock_observer1_.LastEvent());
   EXPECT_EQ(expected_event, mock_observer2_.LastEvent());
 }
@@ skipping 40 matching lines @@
   base::ScopedTempDir data_dir_;
   scoped_refptr<MockSpecialStoragePolicy> storage_policy_;
   scoped_refptr<QuotaManager> quota_manager_;
   MockStorageClient* client_;
 };
 
 // This test simulates a usage change in a quota client and verifies that a
 // storage observer will receive a storage event.
 TEST_F(StorageMonitorIntegrationTest, NotifyUsageEvent) {
   const StorageType kTestStorageType = kStorageTypePersistent;
-  const int64 kTestUsage = 234743;
+  const int64_t kTestUsage = 234743;
 
   // Register the observer.
   StorageObserver::MonitorParams params(kTestStorageType,
                                         GURL(kDefaultOrigin),
                                         base::TimeDelta::FromHours(1),
                                         false);
   MockObserver mock_observer;
   quota_manager_->AddStorageObserver(&mock_observer, params);
 
   // Fire a usage change.
   client_->AddOriginAndNotify(GURL(kDefaultOrigin),
                               kTestStorageType,
                               kTestUsage);
   base::RunLoop().RunUntilIdle();
 
   // Verify that the observer receives it.
   ASSERT_EQ(1, mock_observer.EventCount());
   const StorageObserver::Event& event = mock_observer.LastEvent();
   EXPECT_EQ(params.filter, event.filter);
   EXPECT_EQ(kTestUsage, event.usage);
 }
 
 }  // namespace content