Switch to standard integer types in content/browser/.

content/browser/background_sync/background_sync_manager_unittest.cc

 // Copyright 2015 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 "content/browser/background_sync/background_sync_manager.h"
 
+#include <stdint.h>
+
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/metrics/field_trial.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/power_monitor/power_monitor_source.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/test/mock_entropy_provider.h"
 #include "base/test/simple_test_clock.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/browser/background_sync/background_sync_network_observer.h"
 #include "content/browser/background_sync/background_sync_registration_handle.h"
@@ skipping 15 matching lines @@
 namespace content {
 
 namespace {
 
 const char kPattern1[] = "https://example.com/a";
 const char kPattern2[] = "https://example.com/b";
 const char kScript1[] = "https://example.com/a/script.js";
 const char kScript2[] = "https://example.com/b/script.js";
 
 void RegisterServiceWorkerCallback(bool* called,
-                                   int64* store_registration_id,
+                                   int64_t* store_registration_id,
                                    ServiceWorkerStatusCode status,
                                    const std::string& status_message,
-                                   int64 registration_id) {
+                                   int64_t registration_id) {
   EXPECT_EQ(SERVICE_WORKER_OK, status) << ServiceWorkerStatusToString(status);
   *called = true;
   *store_registration_id = registration_id;
 }
 
 void FindServiceWorkerRegistrationCallback(
     scoped_refptr<ServiceWorkerRegistration>* out_registration,
     ServiceWorkerStatusCode status,
     const scoped_refptr<ServiceWorkerRegistration>& registration) {
   EXPECT_EQ(SERVICE_WORKER_OK, status) << ServiceWorkerStatusToString(status);
@@ skipping 104 matching lines @@
                           const ServiceWorkerVersion::StatusCallback&)>;
 
   explicit TestBackgroundSyncManager(
       const scoped_refptr<ServiceWorkerContextWrapper>& service_worker_context)
       : BackgroundSyncManager(service_worker_context) {
   }
 
   void DoInit() { Init(); }
 
   void StoreDataInBackendContinue(
-      int64 sw_registration_id,
+      int64_t sw_registration_id,
       const GURL& origin,
       const std::string& key,
       const std::string& data,
       const ServiceWorkerStorage::StatusCallback& callback) {
     BackgroundSyncManager::StoreDataInBackend(sw_registration_id, origin, key,
                                               data, callback);
   }
 
   void GetDataFromBackendContinue(
       const std::string& key,
@@ skipping 26 matching lines @@
   void set_has_main_frame_provider_host(bool value) {
     has_main_frame_provider_host_ = value;
   }
 
   const BackgroundSyncParameters* background_sync_parameters() const {
     return parameters_.get();
   }
 
  protected:
   void StoreDataInBackend(
-      int64 sw_registration_id,
+      int64_t sw_registration_id,
       const GURL& origin,
       const std::string& key,
       const std::string& data,
       const ServiceWorkerStorage::StatusCallback& callback) override {
     EXPECT_TRUE(continuation_.is_null());
     if (corrupt_backend_) {
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::Bind(callback, SERVICE_WORKER_ERROR_FAILED));
       return;
     }
     continuation_ =
         base::Bind(&TestBackgroundSyncManager::StoreDataInBackendContinue,
                    base::Unretained(this), sw_registration_id, origin, key,
                    data, callback);
     if (delay_backend_)
       return;
 
     Continue();
   }
 
   void GetDataFromBackend(
       const std::string& key,
       const ServiceWorkerStorage::GetUserDataForAllRegistrationsCallback&
           callback) override {
     EXPECT_TRUE(continuation_.is_null());
     if (corrupt_backend_) {
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE,
-          base::Bind(callback, std::vector<std::pair<int64, std::string>>(),
+          base::Bind(callback, std::vector<std::pair<int64_t, std::string>>(),
                      SERVICE_WORKER_ERROR_FAILED));
       return;
     }
     continuation_ =
         base::Bind(&TestBackgroundSyncManager::GetDataFromBackendContinue,
                    base::Unretained(this), key, callback);
     if (delay_backend_)
       return;
 
     Continue();
@@ skipping 215 matching lines @@
     background_sync_manager_.reset();
     test_background_sync_manager_ = nullptr;
     test_clock_ = nullptr;
   }
 
   bool Register(const BackgroundSyncRegistrationOptions& sync_options) {
     return RegisterWithServiceWorkerId(sw_registration_id_1_, sync_options);
   }
 
   bool RegisterWithServiceWorkerId(
-      int64 sw_registration_id,
+      int64_t sw_registration_id,
       const BackgroundSyncRegistrationOptions& options) {
     bool was_called = false;
     background_sync_manager_->Register(
         sw_registration_id, options, true /* requested_from_service_worker */,
         base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationCallback,
                    base::Unretained(this), &was_called));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
     return callback_status_ == BACKGROUND_SYNC_STATUS_OK;
   }
 
   bool RegisterFromDocumentWithServiceWorkerId(
-      int64 sw_registration_id,
+      int64_t sw_registration_id,
       const BackgroundSyncRegistrationOptions& options) {
     bool was_called = false;
     background_sync_manager_->Register(
         sw_registration_id, options, false /* requested_from_service_worker */,
         base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationCallback,
                    base::Unretained(this), &was_called));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
     return callback_status_ == BACKGROUND_SYNC_STATUS_OK;
   }
 
   bool Unregister(BackgroundSyncRegistrationHandle* registration_handle) {
     return UnregisterWithServiceWorkerId(sw_registration_id_1_,
                                          registration_handle);
   }
 
   bool UnregisterWithServiceWorkerId(
-      int64 sw_registration_id,
+      int64_t sw_registration_id,
       BackgroundSyncRegistrationHandle* registration_handle) {
     bool was_called = false;
     registration_handle->Unregister(
         sw_registration_id,
         base::Bind(&BackgroundSyncManagerTest::StatusCallback,
                    base::Unretained(this), &was_called));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
     return callback_status_ == BACKGROUND_SYNC_STATUS_OK;
   }
@@ skipping 21 matching lines @@
     return callback_finished_state_;
   }
 
   bool GetRegistration(
       const BackgroundSyncRegistrationOptions& registration_options) {
     return GetRegistrationWithServiceWorkerId(sw_registration_id_1_,
                                               registration_options);
   }
 
   bool GetRegistrationWithServiceWorkerId(
-      int64 sw_registration_id,
+      int64_t sw_registration_id,
       const BackgroundSyncRegistrationOptions& registration_options) {
     bool was_called = false;
     background_sync_manager_->GetRegistration(
         sw_registration_id, registration_options.tag,
         registration_options.periodicity,
         base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationCallback,
                    base::Unretained(this), &was_called));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
 
     if (callback_status_ == BACKGROUND_SYNC_STATUS_OK) {
       EXPECT_STREQ(registration_options.tag.c_str(),
                    callback_registration_handle_->options()->tag.c_str());
     }
 
     return callback_status_ == BACKGROUND_SYNC_STATUS_OK;
   }
 
   bool GetRegistrations(SyncPeriodicity periodicity) {
     return GetRegistrationWithServiceWorkerId(sw_registration_id_1_,
                                               periodicity);
   }
 
-  bool GetRegistrationWithServiceWorkerId(int64 sw_registration_id,
+  bool GetRegistrationWithServiceWorkerId(int64_t sw_registration_id,
                                           SyncPeriodicity periodicity) {
     bool was_called = false;
     background_sync_manager_->GetRegistrations(
         sw_registration_id, periodicity,
         base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationsCallback,
                    base::Unretained(this), &was_called));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
 
     return callback_status_ == BACKGROUND_SYNC_STATUS_OK;
   }
 
   void StorageRegistrationCallback(ServiceWorkerStatusCode result) {
     callback_sw_status_code_ = result;
   }
 
-  void UnregisterServiceWorker(uint64 sw_registration_id) {
+  void UnregisterServiceWorker(uint64_t sw_registration_id) {
     bool called = false;
     helper_->context()->UnregisterServiceWorker(
         PatternForSWId(sw_registration_id),
         base::Bind(&UnregisterServiceWorkerCallback, &called));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(called);
   }
 
-  GURL PatternForSWId(int64 sw_id) {
+  GURL PatternForSWId(int64_t sw_id) {
     EXPECT_TRUE(sw_id == sw_registration_id_1_ ||
                 sw_id == sw_registration_id_2_);
     return sw_id == sw_registration_id_1_ ? GURL(kPattern1) : GURL(kPattern2);
   }
 
   void SetupForSyncEvent(
       const TestBackgroundSyncManager::OneShotCallback& callback) {
     test_background_sync_manager_->set_one_shot_callback(callback);
     SetNetwork(net::NetworkChangeNotifier::CONNECTION_WIFI);
   }
@@ skipping 44 matching lines @@
   scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_;
   TestPowerSource* power_monitor_source_ = nullptr;  // owned by power_monitor_
   scoped_ptr<base::PowerMonitor> power_monitor_;
   scoped_ptr<EmbeddedWorkerTestHelper> helper_;
   scoped_ptr<BackgroundSyncManager> background_sync_manager_;
   scoped_ptr<StoragePartitionImpl> storage_partition_impl_;
   TestBackgroundSyncManager* test_background_sync_manager_ = nullptr;
   TestBackgroundSyncController* test_controller_;
   base::SimpleTestClock* test_clock_ = nullptr;
 
-  int64 sw_registration_id_1_;
-  int64 sw_registration_id_2_;
+  int64_t sw_registration_id_1_;
+  int64_t sw_registration_id_2_;
   scoped_refptr<ServiceWorkerRegistration> sw_registration_1_;
   scoped_refptr<ServiceWorkerRegistration> sw_registration_2_;
 
   BackgroundSyncRegistrationOptions sync_options_1_;
   BackgroundSyncRegistrationOptions sync_options_2_;
 
   // Callback values.
   BackgroundSyncStatus callback_status_ = BACKGROUND_SYNC_STATUS_OK;
   scoped_ptr<BackgroundSyncRegistrationHandle> callback_registration_handle_;
   scoped_ptr<ScopedVector<BackgroundSyncRegistrationHandle>>
@@ skipping 1339 matching lines @@
   // Run it again.
   test_clock_->Advance(test_background_sync_manager_->delayed_task_delta());
   test_background_sync_manager_->delayed_task().Run();
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(GetRegistration(sync_options_1_));
   EXPECT_EQ(BACKGROUND_SYNC_EVENT_LAST_CHANCE_IS_LAST_CHANCE,
             test_background_sync_manager_->last_chance());
 }
 
 }  // namespace content