Switch to standard integer types in content/browser/.

content/browser/background_sync/background_sync_manager.h

 // 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.
 
 #ifndef CONTENT_BROWSER_BACKGROUND_SYNC_BACKGROUND_SYNC_MANAGER_H_
 #define CONTENT_BROWSER_BACKGROUND_SYNC_BACKGROUND_SYNC_MANAGER_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/callback_forward.h"
 #include "base/cancelable_callback.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time/clock.h"
 #include "content/browser/background_sync/background_sync.pb.h"
 #include "content/browser/background_sync/background_sync_registration.h"
 #include "content/browser/background_sync/background_sync_registration_handle.h"
 #include "content/browser/background_sync/background_sync_status.h"
 #include "content/browser/cache_storage/cache_storage_scheduler.h"
 #include "content/browser/service_worker/service_worker_context_observer.h"
@@ skipping 35 matching lines @@
       const scoped_refptr<ServiceWorkerContextWrapper>& service_worker_context);
   ~BackgroundSyncManager() override;
 
   // Stores the given background sync registration and adds it to the scheduling
   // queue. It will overwrite an existing registration with the same tag and
   // periodicity unless they're identical (save for the id). Calls |callback|
   // with BACKGROUND_SYNC_STATUS_OK and the accepted registration on success.
   // The accepted registration will have a unique id. It may also have altered
   // parameters if the user or UA chose different parameters than those
   // supplied.
-  void Register(int64 sw_registration_id,
+  void Register(int64_t sw_registration_id,
                 const BackgroundSyncRegistrationOptions& options,
                 bool requested_from_service_worker,
                 const StatusAndRegistrationCallback& callback);
 
   // Finds the background sync registration associated with
   // |sw_registration_id|, periodicity |periodicity|, and tag
   // |sync_registration_tag|. Calls |callback| with
   // BACKGROUND_SYNC_STATUS_NOT_FOUND if it doesn't exist. Calls |callback| with
   // BACKGROUND_SYNC_STATUS_OK on success. If the callback's status
   // is not BACKGROUND_SYNC_STATUS_OK then the callback's RegistrationHandle
   // will be nullptr.
-  void GetRegistration(int64 sw_registration_id,
+  void GetRegistration(int64_t sw_registration_id,
                        const std::string& sync_registration_tag,
                        SyncPeriodicity periodicity,
                        const StatusAndRegistrationCallback& callback);
 
   // Finds the background sync registrations associated with
   // |sw_registration_id| and periodicity |periodicity|. Calls
   // |callback| with BACKGROUND_SYNC_STATUS_OK on success.
-  void GetRegistrations(int64 sw_registration_id,
+  void GetRegistrations(int64_t sw_registration_id,
                         SyncPeriodicity periodicity,
                         const StatusAndRegistrationsCallback& callback);
 
   // Given a HandleId |handle_id|, return a new handle for the same
   // registration.
   scoped_ptr<BackgroundSyncRegistrationHandle> DuplicateRegistrationHandle(
       BackgroundSyncRegistrationHandle::HandleId handle_id);
 
   // ServiceWorkerContextObserver overrides.
-  void OnRegistrationDeleted(int64 sw_registration_id,
+  void OnRegistrationDeleted(int64_t sw_registration_id,
                              const GURL& pattern) override;
   void OnStorageWiped() override;
 
   BackgroundSyncNetworkObserver* GetNetworkObserverForTesting() {
     return network_observer_.get();
   }
 
   void set_clock(scoped_ptr<base::Clock> clock) {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     clock_ = clock.Pass();
@@ skipping 13 matching lines @@
   class RefCountedRegistration;
 
   explicit BackgroundSyncManager(
       const scoped_refptr<ServiceWorkerContextWrapper>& context);
 
   // Init must be called before any public member function. Only call it once.
   void Init();
 
   // The following methods are virtual for testing.
   virtual void StoreDataInBackend(
-      int64 sw_registration_id,
+      int64_t sw_registration_id,
       const GURL& origin,
       const std::string& backend_key,
       const std::string& data,
       const ServiceWorkerStorage::StatusCallback& callback);
   virtual void GetDataFromBackend(
       const std::string& backend_key,
       const ServiceWorkerStorage::GetUserDataForAllRegistrationsCallback&
           callback);
   virtual void FireOneShotSync(
       BackgroundSyncRegistrationHandle::HandleId handle_id,
@@ skipping 32 matching lines @@
 
     BackgroundSyncRegistrations();
     ~BackgroundSyncRegistrations();
 
     RegistrationMap registration_map;
     BackgroundSyncRegistration::RegistrationId next_id;
     GURL origin;
   };
 
   using PermissionStatusCallback = base::Callback<void(bool)>;
-  using SWIdToRegistrationsMap = std::map<int64, BackgroundSyncRegistrations>;
+  using SWIdToRegistrationsMap = std::map<int64_t, BackgroundSyncRegistrations>;
 
   static const size_t kMaxTagLength = 10240;
 
   scoped_ptr<BackgroundSyncRegistrationHandle> CreateRegistrationHandle(
       const scoped_refptr<RefCountedRegistration>& registration);
 
   // Returns the BackgroundSyncRegistration corresponding to |handle_id|.
   // Returns nullptr if the registration is not found.
   BackgroundSyncRegistration* GetRegistrationForHandle(
       BackgroundSyncRegistrationHandle::HandleId handle_id) const;
 
   // The BackgroundSyncManager holds references to registrations that have
   // active Handles. The handles must call this on destruction.
   void ReleaseRegistrationHandle(
       BackgroundSyncRegistrationHandle::HandleId handle_id);
 
   // Disable the manager. Already queued operations will abort once they start
   // to run (in their impl methods). Future operations will not queue. The one
   // exception is already firing events -- their responses will be processed in
   // order to notify their final state.
   // The list of active registrations is cleared and the backend is also cleared
   // (if it's still functioning). The manager will reenable itself once it
   // receives the OnStorageWiped message or on browser restart.
   void DisableAndClearManager(const base::Closure& callback);
   void DisableAndClearDidGetRegistrations(
       const base::Closure& callback,
-      const std::vector<std::pair<int64, std::string>>& user_data,
+      const std::vector<std::pair<int64_t, std::string>>& user_data,
       ServiceWorkerStatusCode status);
   void DisableAndClearManagerClearedOne(const base::Closure& barrier_closure,
                                         ServiceWorkerStatusCode status);
 
   // Returns the existing registration or nullptr if it cannot be found.
   RefCountedRegistration* LookupActiveRegistration(
-      int64 sw_registration_id,
+      int64_t sw_registration_id,
       const RegistrationKey& registration_key);
 
   // Write all registrations for a given |sw_registration_id| to persistent
   // storage.
-  void StoreRegistrations(int64 sw_registration_id,
+  void StoreRegistrations(int64_t sw_registration_id,
                           const ServiceWorkerStorage::StatusCallback& callback);
 
   // Removes the active registration if it is in the map.
-  void RemoveActiveRegistration(int64 sw_registration_id,
+  void RemoveActiveRegistration(int64_t sw_registration_id,
                                 const RegistrationKey& registration_key);
 
   void AddActiveRegistration(
-      int64 sw_registration_id,
+      int64_t sw_registration_id,
       const GURL& origin,
       const scoped_refptr<RefCountedRegistration>& sync_registration);
 
   void InitImpl(const base::Closure& callback);
   void InitDidGetControllerParameters(
       const base::Closure& callback,
       scoped_ptr<BackgroundSyncParameters> parameters);
   void InitDidGetDataFromBackend(
       const base::Closure& callback,
-      const std::vector<std::pair<int64, std::string>>& user_data,
+      const std::vector<std::pair<int64_t, std::string>>& user_data,
       ServiceWorkerStatusCode status);
 
   // Register callbacks
   void RegisterCheckIfHasMainFrame(
-      int64 sw_registration_id,
+      int64_t sw_registration_id,
       const BackgroundSyncRegistrationOptions& options,
       const StatusAndRegistrationCallback& callback);
   void RegisterDidCheckIfMainFrame(
-      int64 sw_registration_id,
+      int64_t sw_registration_id,
       const BackgroundSyncRegistrationOptions& options,
       const StatusAndRegistrationCallback& callback,
       bool has_main_frame_client);
-  void RegisterImpl(int64 sw_registration_id,
+  void RegisterImpl(int64_t sw_registration_id,
                     const BackgroundSyncRegistrationOptions& options,
                     const StatusAndRegistrationCallback& callback);
   void RegisterDidStore(
-      int64 sw_registration_id,
+      int64_t sw_registration_id,
       const scoped_refptr<RefCountedRegistration>& new_registration_ref,
       const StatusAndRegistrationCallback& callback,
       ServiceWorkerStatusCode status);
 
   // Removes the background sync with periodicity |periodicity| and id
   // |sync_registration_id|. Calls |callback| with
   // BACKGROUND_SYNC_STATUS_NOT_FOUND if no match is found. Calls |callback|
   // with BACKGROUND_SYNC_STATUS_OK on success.
-  void Unregister(int64 sw_registration_id,
+  void Unregister(int64_t sw_registration_id,
                   BackgroundSyncRegistrationHandle::HandleId handle_id,
                   const StatusCallback& callback);
   void UnregisterImpl(
-      int64 sw_registration_id,
+      int64_t sw_registration_id,
       const RegistrationKey& key,
       BackgroundSyncRegistration::RegistrationId sync_registration_id,
       SyncPeriodicity periodicity,
       const StatusCallback& callback);
-  void UnregisterDidStore(int64 sw_registration_id,
+  void UnregisterDidStore(int64_t sw_registration_id,
                           SyncPeriodicity periodicity,
                           const StatusCallback& callback,
                           ServiceWorkerStatusCode status);
 
   // NotifyWhenFinished and its callbacks. See
   // BackgroundSyncRegistrationHandle::NotifyWhenFinished for detailed
   // documentation.
   void NotifyWhenFinished(BackgroundSyncRegistrationHandle::HandleId handle_id,
                           const StatusAndStateCallback& callback);
   void NotifyWhenFinishedImpl(
       scoped_ptr<BackgroundSyncRegistrationHandle> registration_handle,
       const StatusAndStateCallback& callback);
   void NotifyWhenFinishedInvokeCallback(const StatusAndStateCallback& callback,
                                         BackgroundSyncState status);
 
   // GetRegistration callbacks
-  void GetRegistrationImpl(int64 sw_registration_id,
+  void GetRegistrationImpl(int64_t sw_registration_id,
                            const RegistrationKey& registration_key,
                            const StatusAndRegistrationCallback& callback);
 
   // GetRegistrations callbacks
-  void GetRegistrationsImpl(int64 sw_registration_id,
+  void GetRegistrationsImpl(int64_t sw_registration_id,
                             SyncPeriodicity periodicity,
                             const StatusAndRegistrationsCallback& callback);
 
   bool AreOptionConditionsMet(const BackgroundSyncRegistrationOptions& options);
   bool IsRegistrationReadyToFire(
       const BackgroundSyncRegistration& registration);
 
   // Determines if the browser needs to be able to run in the background (e.g.,
   // to run a pending registration or verify that a firing registration
   // completed). If background processing is required it calls out to the
@@ skipping 14 matching lines @@
       const base::Closure& event_completed_callback,
       ServiceWorkerStatusCode service_worker_status,
       const scoped_refptr<ServiceWorkerRegistration>&
           service_worker_registration);
   void FireReadyEventsAllEventsFiring(const base::Closure& callback);
 
   // Called when a sync event has completed.
   void EventComplete(
       const scoped_refptr<ServiceWorkerRegistration>&
           service_worker_registration,
-      int64 service_worker_id,
+      int64_t service_worker_id,
       scoped_ptr<BackgroundSyncRegistrationHandle> registration_handle,
       const base::Closure& callback,
       ServiceWorkerStatusCode status_code);
   void EventCompleteImpl(
-      int64 service_worker_id,
+      int64_t service_worker_id,
       scoped_ptr<BackgroundSyncRegistrationHandle> registration_handle,
       ServiceWorkerStatusCode status_code,
       const base::Closure& callback);
-  void EventCompleteDidStore(int64 service_worker_id,
+  void EventCompleteDidStore(int64_t service_worker_id,
                              const base::Closure& callback,
                              ServiceWorkerStatusCode status_code);
 
   // Called when all sync events have completed.
   static void OnAllSyncEventsCompleted(const base::TimeTicks& start_time,
                                        int number_of_batched_sync_events);
 
   // OnRegistrationDeleted callbacks
-  void OnRegistrationDeletedImpl(int64 sw_registration_id,
+  void OnRegistrationDeletedImpl(int64_t sw_registration_id,
                                  const base::Closure& callback);
 
   // OnStorageWiped callbacks
   void OnStorageWipedImpl(const base::Closure& callback);
 
   void OnNetworkChanged();
   void OnPowerChanged();
 
   // Operation Scheduling callback and convenience functions.
   template <typename CallbackT, typename... Params>
@@ skipping 41 matching lines @@
   scoped_ptr<base::Clock> clock_;
 
   base::WeakPtrFactory<BackgroundSyncManager> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BackgroundSyncManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_BACKGROUND_SYNC_BACKGROUND_SYNC_MANAGER_H_