Switch to standard integer types in chrome/browser/, part 3 of 4.

chrome/browser/policy/cloud/cloud_policy_invalidator_unittest.cc

 // Copyright 2013 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 <string>
 
-#include "base/basictypes.h"
 #include "base/bind.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/metrics/sample_map.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/run_loop.h"
 #include "base/test/simple_test_clock.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/time/time.h"
 #include "base/values.h"
+#include "build/build_config.h"
 #include "chrome/browser/invalidation/fake_invalidation_service.h"
 #include "chrome/browser/policy/cloud/cloud_policy_invalidator.h"
 #include "chrome/browser/policy/cloud/user_cloud_policy_invalidator.h"
 #include "components/invalidation/public/invalidation_util.h"
 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
 #include "components/policy/core/common/cloud/cloud_policy_core.h"
 #include "components/policy/core/common/cloud/cloud_policy_refresh_scheduler.h"
 #include "components/policy/core/common/cloud/enterprise_metrics.h"
 #include "components/policy/core/common/cloud/mock_cloud_policy_client.h"
 #include "components/policy/core/common/cloud/mock_cloud_policy_store.h"
@@ skipping 19 matching lines @@
 
   void TearDown() override;
 
   // Starts the invalidator which will be tested.
   // |initialize| determines if the invalidator should be initialized.
   // |start_refresh_scheduler| determines if the refresh scheduler should start.
   // |highest_handled_invalidation_version| is the highest invalidation version
   // that was handled already before this invalidator was created.
   void StartInvalidator(bool initialize,
                         bool start_refresh_scheduler,
-                        int64 highest_handled_invalidation_version);
+                        int64_t highest_handled_invalidation_version);
   void StartInvalidator() {
     StartInvalidator(true, /* initialize */
                      true, /* start_refresh_scheduler */
                      0     /* highest_handled_invalidation_version */);
   }
 
   // Calls Initialize on the invalidator.
   void InitializeInvalidator();
 
   // Calls Shutdown on the invalidator. Test must call DestroyInvalidator
@@ skipping 12 matching lines @@
   // Disconnects the cloud policy core.
   void DisconnectCore();
 
   // Simulates storing a new policy to the policy store.
   // |object| determines which policy object the store will report the
   // invalidator should register for. May be POLICY_OBJECT_NONE for no object.
   // |invalidation_version| determines what invalidation the store will report.
   // |policy_changed| determines whether a policy value different from the
   // current value will be stored.
   // |time| determines the timestamp the store will report.
-  void StorePolicy(
-      PolicyObject object,
-      int64 invalidation_version,
-      bool policy_changed,
-      const base::Time& time);
-  void StorePolicy(
-      PolicyObject object,
-      int64 invalidation_version,
-      bool policy_changed) {
+  void StorePolicy(PolicyObject object,
+                   int64_t invalidation_version,
+                   bool policy_changed,
+                   const base::Time& time);
+  void StorePolicy(PolicyObject object,
+                   int64_t invalidation_version,
+                   bool policy_changed) {
     StorePolicy(object,
                 invalidation_version,
                 policy_changed,
                 Now() - base::TimeDelta::FromMinutes(5));
   }
-  void StorePolicy(PolicyObject object, int64 invalidation_version) {
+  void StorePolicy(PolicyObject object, int64_t invalidation_version) {
     StorePolicy(object, invalidation_version, false);
   }
   void StorePolicy(PolicyObject object) {
     StorePolicy(object, 0);
   }
 
   // Disables the invalidation service. It is enabled by default.
   void DisableInvalidationService();
 
   // Enables the invalidation service. It is enabled by default.
   void EnableInvalidationService();
 
   // Causes the invalidation service to fire an invalidation.
-  syncer::Invalidation FireInvalidation(
-      PolicyObject object,
-      int64 version,
-      const std::string& payload);
+  syncer::Invalidation FireInvalidation(PolicyObject object,
+                                        int64_t version,
+                                        const std::string& payload);
 
   // Causes the invalidation service to fire an invalidation with unknown
   // version.
   syncer::Invalidation FireUnknownVersionInvalidation(PolicyObject object);
 
   // Checks the expected value of the currently set invalidation info.
-  bool CheckInvalidationInfo(int64 version, const std::string& payload);
+  bool CheckInvalidationInfo(int64_t version, const std::string& payload);
 
   // Checks that the policy was not refreshed due to an invalidation.
   bool CheckPolicyNotRefreshed();
 
   // Checks that the policy was refreshed due to an invalidation within an
   // appropriate timeframe depending on whether the invalidation had unknown
   // version.
   bool CheckPolicyRefreshed();
   bool CheckPolicyRefreshedWithUnknownVersion();
 
   bool IsUnsent(const syncer::Invalidation& invalidation);
 
   // Returns the invalidations enabled state set by the invalidator on the
   // refresh scheduler.
   bool InvalidationsEnabled();
 
   // Determines if the invalidation with the given ack handle has been
   // acknowledged.
   bool IsInvalidationAcknowledged(const syncer::Invalidation& invalidation);
 
   // Determines if the invalidator has registered for an object with the
   // invalidation service.
   bool IsInvalidatorRegistered();
 
   // Returns the highest invalidation version that was handled already according
   // to the |invalidator_|.
-  int64 GetHighestHandledInvalidationVersion() const;
+  int64_t GetHighestHandledInvalidationVersion() const;
 
   // Advance the test clock.
   void AdvanceClock(base::TimeDelta delta);
 
   // Get the current time on the test clock.
   base::Time Now();
 
   // Translate a version number into an appropriate invalidation version (which
   // is based on the current time).
-  int64 V(int version);
+  int64_t V(int version);
 
   // Get an invalidation version for the given time.
-  int64 GetVersion(base::Time time);
+  int64_t GetVersion(base::Time time);
 
   // Get the policy type that the |invalidator_| is responsible for.
   virtual em::DeviceRegisterRequest::Type GetPolicyType() const;
 
  private:
   // Checks that the policy was refreshed due to an invalidation with the given
   // base delay.
   bool CheckPolicyRefreshed(base::TimeDelta delay);
 
   // Checks that the policy was refreshed the given number of times.
@@ skipping 47 matching lines @@
 
 void CloudPolicyInvalidatorTest::TearDown() {
   if (invalidator_)
     invalidator_->Shutdown();
   core_.Disconnect();
 }
 
 void CloudPolicyInvalidatorTest::StartInvalidator(
     bool initialize,
     bool start_refresh_scheduler,
-    int64 highest_handled_invalidation_version) {
+    int64_t highest_handled_invalidation_version) {
   invalidator_.reset(new CloudPolicyInvalidator(
       GetPolicyType(),
       &core_,
       task_runner_,
       scoped_ptr<base::Clock>(clock_),
       highest_handled_invalidation_version));
   if (start_refresh_scheduler) {
     ConnectCore();
     StartRefreshScheduler();
   }
@@ skipping 21 matching lines @@
 
 void CloudPolicyInvalidatorTest::StartRefreshScheduler() {
   core_.StartRefreshScheduler();
 }
 
 void CloudPolicyInvalidatorTest::DisconnectCore() {
   client_ = nullptr;
   core_.Disconnect();
 }
 
-void CloudPolicyInvalidatorTest::StorePolicy(
-    PolicyObject object,
-    int64 invalidation_version,
-    bool policy_changed,
-    const base::Time& time) {
+void CloudPolicyInvalidatorTest::StorePolicy(PolicyObject object,
+                                             int64_t invalidation_version,
+                                             bool policy_changed,
+                                             const base::Time& time) {
   em::PolicyData* data = new em::PolicyData();
   if (object != POLICY_OBJECT_NONE) {
     data->set_invalidation_source(GetPolicyObjectId(object).source());
     data->set_invalidation_name(GetPolicyObjectId(object).name());
   }
   data->set_timestamp((time - base::Time::UnixEpoch()).InMilliseconds());
   // Swap the policy value if a policy change is desired.
   if (policy_changed)
     policy_value_cur_ = policy_value_cur_ == policy_value_a_ ?
         policy_value_b_ : policy_value_a_;
@@ skipping 16 matching lines @@
   invalidation_service_.SetInvalidatorState(
       syncer::TRANSIENT_INVALIDATION_ERROR);
 }
 
 void CloudPolicyInvalidatorTest::EnableInvalidationService() {
   invalidation_service_.SetInvalidatorState(syncer::INVALIDATIONS_ENABLED);
 }
 
 syncer::Invalidation CloudPolicyInvalidatorTest::FireInvalidation(
     PolicyObject object,
-    int64 version,
+    int64_t version,
     const std::string& payload) {
   syncer::Invalidation invalidation = syncer::Invalidation::Init(
       GetPolicyObjectId(object),
       version,
       payload);
   invalidation_service_.EmitInvalidationForTest(invalidation);
   return invalidation;
 }
 
 syncer::Invalidation CloudPolicyInvalidatorTest::FireUnknownVersionInvalidation(
     PolicyObject object) {
   syncer::Invalidation invalidation = syncer::Invalidation::InitUnknownVersion(
       GetPolicyObjectId(object));
   invalidation_service_.EmitInvalidationForTest(invalidation);
   return invalidation;
 }
 
 bool CloudPolicyInvalidatorTest::CheckInvalidationInfo(
-    int64 version,
+    int64_t version,
     const std::string& payload) {
   MockCloudPolicyClient* client =
       static_cast<MockCloudPolicyClient*>(core_.client());
   return version == client->invalidation_version_ &&
       payload == client->invalidation_payload_;
 }
 
 bool CloudPolicyInvalidatorTest::CheckPolicyNotRefreshed() {
   return CheckPolicyRefreshCount(0);
 }
@@ skipping 25 matching lines @@
 
   EXPECT_FALSE(IsUnsent(invalidation));
   return !invalidation_service_.GetMockAckHandler()->IsUnacked(invalidation);
 }
 
 bool CloudPolicyInvalidatorTest::IsInvalidatorRegistered() {
   return !invalidation_service_.invalidator_registrar()
       .GetRegisteredIds(invalidator_.get()).empty();
 }
 
-int64 CloudPolicyInvalidatorTest::GetHighestHandledInvalidationVersion() const {
+int64_t CloudPolicyInvalidatorTest::GetHighestHandledInvalidationVersion()
+    const {
   return invalidator_->highest_handled_invalidation_version();
 }
 
 void CloudPolicyInvalidatorTest::AdvanceClock(base::TimeDelta delta) {
   clock_->Advance(delta);
 }
 
 base::Time CloudPolicyInvalidatorTest::Now() {
   return clock_->Now();
 }
 
-int64 CloudPolicyInvalidatorTest::V(int version) {
+int64_t CloudPolicyInvalidatorTest::V(int version) {
   return GetVersion(Now()) + version;
 }
 
-int64 CloudPolicyInvalidatorTest::GetVersion(base::Time time) {
+int64_t CloudPolicyInvalidatorTest::GetVersion(base::Time time) {
   return (time - base::Time::UnixEpoch()).InMicroseconds();
 }
 
 em::DeviceRegisterRequest::Type
 CloudPolicyInvalidatorTest::GetPolicyType() const {
   return UserCloudPolicyInvalidator::GetPolicyType();
 }
 
 bool CloudPolicyInvalidatorTest::CheckPolicyRefreshed(base::TimeDelta delay) {
   base::TimeDelta max_delay = delay + base::TimeDelta::FromMilliseconds(
@@ skipping 688 matching lines @@
     CloudPolicyInvalidatorUserTypedTest,
     testing::Values(em::DeviceRegisterRequest::IOS_BROWSER));
 #else
 INSTANTIATE_TEST_CASE_P(
     CloudPolicyInvalidatorUserTypedTestInstance,
     CloudPolicyInvalidatorUserTypedTest,
     testing::Values(em::DeviceRegisterRequest::BROWSER));
 #endif
 
 }  // namespace policy