Switch to standard integer types in content/browser/.

content/browser/geofencing/geofencing_manager_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 "base/callback.h"
 #include "base/message_loop/message_loop.h"
 #include "content/browser/geofencing/geofencing_manager.h"
 #include "content/browser/geofencing/geofencing_service.h"
 #include "content/browser/service_worker/embedded_worker_test_helper.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebCircularGeofencingRegion.h"
 
 using blink::WebCircularGeofencingRegion;
 typedef std::map<std::string, WebCircularGeofencingRegion> RegionMap;
 
 namespace {
 
 static const char* kTestRegionId = "region-id";
-static const int64 kTestGeofencingRegistrationId = 42;
-static const int64 kTestGeofencingRegistrationId2 = 43;
+static const int64_t kTestGeofencingRegistrationId = 42;
+static const int64_t kTestGeofencingRegistrationId2 = 43;
 
 bool RegionsMatch(const WebCircularGeofencingRegion& expected,
                   const WebCircularGeofencingRegion& arg) {
   return testing::Matches(expected.latitude)(arg.latitude) &&
          testing::Matches(expected.longitude)(arg.longitude) &&
          testing::Matches(expected.radius)(arg.radius);
 }
 }
 
 namespace content {
 
 class TestGeofencingService : public GeofencingService {
  public:
   TestGeofencingService() : is_available_(false) {}
 
   bool IsServiceAvailable() override { return is_available_; }
 
   void SetIsServiceAvailable(bool is_available) {
     is_available_ = is_available;
   }
 
   MOCK_METHOD2(RegisterRegion,
-               int64(const WebCircularGeofencingRegion& region,
-                     GeofencingRegistrationDelegate* delegate));
-  MOCK_METHOD1(UnregisterRegion, void(int64 geofencing_registration_id));
+               int64_t(const WebCircularGeofencingRegion& region,
+                       GeofencingRegistrationDelegate* delegate));
+  MOCK_METHOD1(UnregisterRegion, void(int64_t geofencing_registration_id));
 
  private:
   bool is_available_;
 };
 
 ACTION_P(SaveDelegate, delegate) {
   *delegate = arg1;
 }
 
 ACTION_P(QuitRunner, runner) {
@@ skipping 21 matching lines @@
     return result_;
   }
 
  private:
   bool was_called_;
   GeofencingStatus result_;
   scoped_refptr<MessageLoopRunner> runner_;
 };
 
 void SaveResponseCallback(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;
 }
 
 ServiceWorkerContextCore::RegistrationCallback MakeRegisteredCallback(
     bool* called,
-    int64* store_registration_id) {
+    int64_t* store_registration_id) {
   return base::Bind(&SaveResponseCallback, called, store_registration_id);
 }
 
 void CallCompletedCallback(bool* called, ServiceWorkerStatusCode) {
   *called = true;
 }
 
 ServiceWorkerContextCore::UnregistrationCallback MakeUnregisteredCallback(
     bool* called) {
   return base::Bind(&CallCompletedCallback, called);
@@ skipping 27 matching lines @@
     service_ = nullptr;
     helper_.reset();
   }
 
   void SetHasProviderForTests() { service_->SetIsServiceAvailable(true); }
 
   scoped_refptr<ServiceWorkerRegistration> RegisterServiceWorker(
       const std::string& name) {
     GURL pattern("http://www.example.com/" + name);
     GURL script_url("http://www.example.com/service_worker.js");
-    int64 registration_id = kInvalidServiceWorkerRegistrationId;
+    int64_t registration_id = kInvalidServiceWorkerRegistrationId;
     bool called = false;
     helper_->context()->RegisterServiceWorker(
         pattern, script_url, nullptr,
         MakeRegisteredCallback(&called, &registration_id));
 
     EXPECT_FALSE(called);
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(called);
     scoped_refptr<ServiceWorkerRegistration> worker(
         new ServiceWorkerRegistration(pattern, registration_id,
                                       helper_->context()->AsWeakPtr()));
     // ServiceWorkerRegistration posts a notification task on construction.
     base::RunLoop().RunUntilIdle();
     return worker;
   }
 
   void UnregisterServiceWorker(
       const scoped_refptr<ServiceWorkerRegistration>& registration) {
     bool called = false;
     helper_->context()->UnregisterServiceWorker(
         registration->pattern(), MakeUnregisteredCallback(&called));
 
     EXPECT_FALSE(called);
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(called);
   }
 
   GeofencingStatus RegisterRegionSync(
-      int64 service_worker_registration_id,
+      int64_t service_worker_registration_id,
       const std::string& id,
       const WebCircularGeofencingRegion& region) {
     StatusCatcher result;
     manager_->RegisterRegion(
         service_worker_registration_id,
         id,
         region,
         base::Bind(&StatusCatcher::Done, base::Unretained(&result)));
     return result.Wait();
   }
 
   GeofencingStatus RegisterRegionSyncWithServiceResult(
-      int64 service_worker_registration_id,
+      int64_t service_worker_registration_id,
       const std::string& id,
       const WebCircularGeofencingRegion& region,
       GeofencingStatus service_status,
-      int64 geofencing_registration_id) {
+      int64_t geofencing_registration_id) {
     StatusCatcher result;
     GeofencingRegistrationDelegate* delegate = 0;
     EXPECT_CALL(
         *service_,
         RegisterRegion(WebCircularGeofencingRegionEq(region), testing::_))
         .WillOnce(testing::DoAll(SaveDelegate(&delegate),
                                  testing::Return(geofencing_registration_id)));
     manager_->RegisterRegion(
         service_worker_registration_id,
         id,
         region,
         base::Bind(&StatusCatcher::Done, base::Unretained(&result)));
     CHECK(delegate);
     delegate->RegistrationFinished(geofencing_registration_id, service_status);
     return result.Wait();
   }
 
-  GeofencingStatus UnregisterRegionSync(int64 service_worker_registration_id,
-                                        const std::string& id,
-                                        bool should_call_service,
-                                        int64 geofencing_registration_id = 0) {
+  GeofencingStatus UnregisterRegionSync(
+      int64_t service_worker_registration_id,
+      const std::string& id,
+      bool should_call_service,
+      int64_t geofencing_registration_id = 0) {
     StatusCatcher result;
     if (should_call_service) {
       EXPECT_CALL(*service_, UnregisterRegion(geofencing_registration_id));
     }
     manager_->UnregisterRegion(
         service_worker_registration_id,
         id,
         base::Bind(&StatusCatcher::Done, base::Unretained(&result)));
     return result.Wait();
   }
 
-  void VerifyRegions(int64 service_worker_registration_id,
+  void VerifyRegions(int64_t service_worker_registration_id,
                      const RegionMap& expected_regions) {
     RegionMap regions;
     EXPECT_EQ(GEOFENCING_STATUS_OK,
               manager_->GetRegisteredRegions(service_worker_registration_id,
                                              &regions));
     EXPECT_EQ(expected_regions.size(), regions.size());
     for (RegionMap::const_iterator it = expected_regions.begin();
          it != expected_regions.end();
          ++it) {
       EXPECT_THAT(regions[it->first],
@@ skipping 266 matching lines @@
                 GEOFENCING_STATUS_OK, kTestGeofencingRegistrationId));
   VerifyRegions(worker1_->id(), expected_regions_);
 
   EXPECT_CALL(*service_, UnregisterRegion(kTestGeofencingRegistrationId));
 
   manager_->SetMockProvider(GeofencingMockState::SERVICE_AVAILABLE);
   VerifyRegions(worker1_->id(), RegionMap());
 }
 
 }  // namespace content