Switch to standard integer types in content/browser/.

content/browser/geofencing/geofencing_manager.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 "content/browser/geofencing/geofencing_manager.h"
 
 #include <algorithm>
 
 #include "base/callback.h"
 #include "content/browser/geofencing/geofencing_service.h"
 #include "content/browser/geofencing/mock_geofencing_service.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/storage_partition.h"
 #include "third_party/WebKit/public/platform/WebCircularGeofencingRegion.h"
 #include "third_party/WebKit/public/platform/WebGeofencingEventType.h"
 #include "url/gurl.h"
 
 namespace content {
 
 struct GeofencingManager::Registration {
-  Registration(int64 service_worker_registration_id,
+  Registration(int64_t service_worker_registration_id,
                const GURL& service_worker_origin,
                const std::string& region_id,
                const blink::WebCircularGeofencingRegion& region,
                const StatusCallback& callback,
-               int64 geofencing_registration_id);
-  int64 service_worker_registration_id;
+               int64_t geofencing_registration_id);
+  int64_t service_worker_registration_id;
   GURL service_worker_origin;
   std::string region_id;
   blink::WebCircularGeofencingRegion region;
 
   // Registration ID as returned by the |GeofencingService|.
-  int64 geofencing_registration_id;
+  int64_t geofencing_registration_id;
 
   // Callback to call when registration is completed. This field is reset when
   // registration is complete.
   StatusCallback registration_callback;
 
   // Returns true if registration has been completed, and thus should be
   // included in calls to GetRegisteredRegions.
   bool is_active() const { return registration_callback.is_null(); }
 };
 
 GeofencingManager::Registration::Registration(
-    int64 service_worker_registration_id,
+    int64_t service_worker_registration_id,
     const GURL& service_worker_origin,
     const std::string& region_id,
     const blink::WebCircularGeofencingRegion& region,
     const GeofencingManager::StatusCallback& callback,
-    int64 geofencing_registration_id)
+    int64_t geofencing_registration_id)
     : service_worker_registration_id(service_worker_registration_id),
       service_worker_origin(service_worker_origin),
       region_id(region_id),
       region(region),
       geofencing_registration_id(geofencing_registration_id),
-      registration_callback(callback) {
-}
+      registration_callback(callback) {}
 
 GeofencingManager::GeofencingManager(
     const scoped_refptr<ServiceWorkerContextWrapper>& service_worker_context)
     : service_(nullptr), service_worker_context_(service_worker_context) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
 GeofencingManager::~GeofencingManager() {
 }
 
@@ skipping 23 matching lines @@
   service_worker_context_->RemoveObserver(this);
   // Clean up all registrations with the |GeofencingService|.
   // TODO(mek): This will need to change to support geofence registrations that
   //     outlive the browser, although removing the references to this
   //     |GeofencingManager| from the |GeofencingService| will still be needed.
   for (const auto& registration : registrations_by_id_)
     service_->UnregisterRegion(registration.first);
 }
 
 void GeofencingManager::RegisterRegion(
-    int64 service_worker_registration_id,
+    int64_t service_worker_registration_id,
     const std::string& region_id,
     const blink::WebCircularGeofencingRegion& region,
     const StatusCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // TODO(mek): Validate region_id and region.
 
   // Look up service worker.
   ServiceWorkerRegistration* service_worker_registration =
       service_worker_context_->GetLiveRegistration(
@@ skipping 16 matching lines @@
     // TODO(mek): Use a more specific error code.
     callback.Run(GEOFENCING_STATUS_ERROR);
     return;
   }
 
   AddRegistration(service_worker_registration_id, service_worker_origin,
                   region_id, region, callback,
                   service_->RegisterRegion(region, this));
 }
 
-void GeofencingManager::UnregisterRegion(int64 service_worker_registration_id,
+void GeofencingManager::UnregisterRegion(int64_t service_worker_registration_id,
                                          const std::string& region_id,
                                          const StatusCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // TODO(mek): Validate region_id.
 
   // Look up service worker.
   ServiceWorkerRegistration* service_worker_registration =
       service_worker_context_->GetLiveRegistration(
           service_worker_registration_id);
@@ skipping 20 matching lines @@
     callback.Run(GEOFENCING_STATUS_UNREGISTRATION_FAILED_NOT_REGISTERED);
     return;
   }
 
   service_->UnregisterRegion(registration->geofencing_registration_id);
   ClearRegistration(registration);
   callback.Run(GEOFENCING_STATUS_OK);
 }
 
 GeofencingStatus GeofencingManager::GetRegisteredRegions(
-    int64 service_worker_registration_id,
+    int64_t service_worker_registration_id,
     std::map<std::string, blink::WebCircularGeofencingRegion>* result) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   CHECK(result);
 
   // Look up service worker.
   ServiceWorkerRegistration* service_worker_registration =
       service_worker_context_->GetLiveRegistration(
           service_worker_registration_id);
   if (!service_worker_registration) {
     return GEOFENCING_STATUS_OPERATION_FAILED_NO_SERVICE_WORKER;
@@ skipping 41 matching lines @@
 }
 
 void GeofencingManager::SetMockPosition(double latitude, double longitude) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!mock_service_)
     return;
   mock_service_->SetMockPosition(latitude, longitude);
 }
 
 void GeofencingManager::OnRegistrationDeleted(
-    int64 service_worker_registration_id,
+    int64_t service_worker_registration_id,
     const GURL& pattern) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   CleanUpForServiceWorker(service_worker_registration_id);
 }
 
-void GeofencingManager::RegistrationFinished(int64 geofencing_registration_id,
+void GeofencingManager::RegistrationFinished(int64_t geofencing_registration_id,
                                              GeofencingStatus status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   Registration* registration = FindRegistrationById(geofencing_registration_id);
   DCHECK(registration);
   DCHECK(!registration->is_active());
   registration->registration_callback.Run(status);
   registration->registration_callback.Reset();
 
   // If the registration wasn't succesful, remove it from our storage.
   if (status != GEOFENCING_STATUS_OK)
     ClearRegistration(registration);
 }
 
-void GeofencingManager::RegionEntered(int64 geofencing_registration_id) {
+void GeofencingManager::RegionEntered(int64_t geofencing_registration_id) {
   DispatchGeofencingEvent(blink::WebGeofencingEventTypeEnter,
                           geofencing_registration_id);
 }
 
-void GeofencingManager::RegionExited(int64 geofencing_registration_id) {
+void GeofencingManager::RegionExited(int64_t geofencing_registration_id) {
   DispatchGeofencingEvent(blink::WebGeofencingEventTypeLeave,
                           geofencing_registration_id);
 }
 
 GeofencingManager::Registration* GeofencingManager::FindRegistration(
-    int64 service_worker_registration_id,
+    int64_t service_worker_registration_id,
     const std::string& region_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   ServiceWorkerRegistrationsMap::iterator registrations_iterator =
       registrations_.find(service_worker_registration_id);
   if (registrations_iterator == registrations_.end())
     return nullptr;
   RegionIdRegistrationMap::iterator registration =
       registrations_iterator->second.find(region_id);
   if (registration == registrations_iterator->second.end())
     return nullptr;
   return &registration->second;
 }
 
 GeofencingManager::Registration* GeofencingManager::FindRegistrationById(
-    int64 geofencing_registration_id) {
+    int64_t geofencing_registration_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   RegistrationIdRegistrationMap::iterator registration_iterator =
       registrations_by_id_.find(geofencing_registration_id);
   if (registration_iterator == registrations_by_id_.end())
     return nullptr;
   return &registration_iterator->second->second;
 }
 
 GeofencingManager::Registration& GeofencingManager::AddRegistration(
-    int64 service_worker_registration_id,
+    int64_t service_worker_registration_id,
     const GURL& service_worker_origin,
     const std::string& region_id,
     const blink::WebCircularGeofencingRegion& region,
     const StatusCallback& callback,
-    int64 geofencing_registration_id) {
+    int64_t geofencing_registration_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!FindRegistration(service_worker_registration_id, region_id));
   RegionIdRegistrationMap::iterator registration =
       registrations_[service_worker_registration_id]
           .insert(std::make_pair(region_id,
                                  Registration(service_worker_registration_id,
                                               service_worker_origin,
                                               region_id,
                                               region,
                                               callback,
                                               geofencing_registration_id)))
           .first;
   registrations_by_id_[geofencing_registration_id] = registration;
   return registration->second;
 }
 
 void GeofencingManager::ClearRegistration(Registration* registration) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   registrations_by_id_.erase(registration->geofencing_registration_id);
   ServiceWorkerRegistrationsMap::iterator registrations_iterator =
       registrations_.find(registration->service_worker_registration_id);
   DCHECK(registrations_iterator != registrations_.end());
   registrations_iterator->second.erase(registration->region_id);
   if (registrations_iterator->second.empty())
     registrations_.erase(registrations_iterator);
 }
 
 void GeofencingManager::CleanUpForServiceWorker(
-    int64 service_worker_registration_id) {
+    int64_t service_worker_registration_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   ServiceWorkerRegistrationsMap::iterator registrations_iterator =
       registrations_.find(service_worker_registration_id);
   if (registrations_iterator == registrations_.end())
     return;
 
   for (const auto& registration : registrations_iterator->second) {
     int geofencing_registration_id =
         registration.second.geofencing_registration_id;
     service_->UnregisterRegion(geofencing_registration_id);
     registrations_by_id_.erase(geofencing_registration_id);
   }
   registrations_.erase(service_worker_registration_id);
 }
 
 void GeofencingManager::DispatchGeofencingEvent(
     blink::WebGeofencingEventType event_type,
-    int64 geofencing_registration_id) {
+    int64_t geofencing_registration_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   Registration* registration = FindRegistrationById(geofencing_registration_id);
   if (!registration ||
       registration->service_worker_registration_id ==
           kInvalidServiceWorkerRegistrationId) {
     // TODO(mek): Log/track these failures.
     return;
   }
 
   service_worker_context_->FindReadyRegistrationForId(
       registration->service_worker_registration_id,
       registration->service_worker_origin,
       base::Bind(&GeofencingManager::DeliverGeofencingEvent,
                  this,
                  event_type,
                  geofencing_registration_id));
 }
 
 void GeofencingManager::DeliverGeofencingEvent(
     blink::WebGeofencingEventType event_type,
-    int64 geofencing_registration_id,
+    int64_t geofencing_registration_id,
     ServiceWorkerStatusCode service_worker_status,
     const scoped_refptr<ServiceWorkerRegistration>&
         service_worker_registration) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   Registration* registration = FindRegistrationById(geofencing_registration_id);
   if (!registration) {
     // Geofence got unregistered in the meantime, no longer need to deliver
     // event.
     return;
   }
@@ skipping 21 matching lines @@
 }
 
 void GeofencingManager::DeliverGeofencingEventEnd(
     const scoped_refptr<ServiceWorkerRegistration>& service_worker_registration,
     ServiceWorkerStatusCode service_worker_status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // TODO(mek): log/check result.
 }
 
 }  // namespace content