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

chrome/browser/policy/cloud/cloud_policy_invalidator.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 "chrome/browser/policy/cloud/cloud_policy_invalidator.h"
 
 #include "base/bind.h"
 #include "base/hash.h"
 #include "base/location.h"
 #include "base/metrics/histogram.h"
@@ skipping 17 matching lines @@
 const int CloudPolicyInvalidator::kMaxFetchDelayMax = 300000;
 const int CloudPolicyInvalidator::kInvalidationGracePeriod = 10;
 const int CloudPolicyInvalidator::kUnknownVersionIgnorePeriod = 30;
 const int CloudPolicyInvalidator::kMaxInvalidationTimeDelta = 300;
 
 CloudPolicyInvalidator::CloudPolicyInvalidator(
     enterprise_management::DeviceRegisterRequest::Type type,
     CloudPolicyCore* core,
     const scoped_refptr<base::SequencedTaskRunner>& task_runner,
     scoped_ptr<base::Clock> clock,
-    int64 highest_handled_invalidation_version)
+    int64_t highest_handled_invalidation_version)
     : state_(UNINITIALIZED),
       type_(type),
       core_(core),
       task_runner_(task_runner),
       clock_(clock.Pass()),
       invalidation_service_(NULL),
       invalidations_enabled_(false),
       invalidation_service_enabled_(false),
       is_registered_(false),
       invalid_(false),
@@ skipping 111 matching lines @@
     if (type_ == enterprise_management::DeviceRegisterRequest::DEVICE) {
       UMA_HISTOGRAM_ENUMERATION(kMetricDevicePolicyRefresh,
                                 GetPolicyRefreshMetric(policy_changed),
                                 METRIC_POLICY_REFRESH_SIZE);
     } else {
       UMA_HISTOGRAM_ENUMERATION(kMetricUserPolicyRefresh,
                                 GetPolicyRefreshMetric(policy_changed),
                                 METRIC_POLICY_REFRESH_SIZE);
     }
 
-    const int64 store_invalidation_version = store->invalidation_version();
+    const int64_t store_invalidation_version = store->invalidation_version();
 
     // If the policy was invalid and the version stored matches the latest
     // invalidation version, acknowledge the latest invalidation.
     if (invalid_ && store_invalidation_version == invalidation_version_)
       AcknowledgeInvalidation();
 
     // Update the highest invalidation version that was handled already.
     if (store_invalidation_version > highest_handled_invalidation_version_)
       highest_handled_invalidation_version_ = store_invalidation_version;
   }
@@ skipping 24 matching lines @@
   // If there is still a pending invalidation, acknowledge it, since we only
   // care about the latest invalidation.
   if (invalid_)
     AcknowledgeInvalidation();
 
   // Get the version and payload from the invalidation.
   // When an invalidation with unknown version is received, use negative
   // numbers based on the number of such invalidations received. This
   // ensures that the version numbers do not collide with "real" versions
   // (which are positive) or previous invalidations with unknown version.
-  int64 version;
+  int64_t version;
   std::string payload;
   if (invalidation.is_unknown_version()) {
     version = -(++unknown_version_invalidation_count_);
   } else {
     version = invalidation.version();
     payload = invalidation.payload();
   }
 
   // Ignore the invalidation if it is expired.
   bool is_expired = IsInvalidationExpired(version);
@@ skipping 147 matching lines @@
   invalidation_->Acknowledge();
   invalidation_.reset();
   // Cancel any scheduled policy refreshes.
   weak_factory_.InvalidateWeakPtrs();
 }
 
 bool CloudPolicyInvalidator::IsPolicyChanged(
     const enterprise_management::PolicyData* policy) {
   // Determine if the policy changed by comparing its hash value to the
   // previous policy's hash value.
-  uint32 new_hash_value = 0;
+  uint32_t new_hash_value = 0;
   if (policy && policy->has_policy_value())
     new_hash_value = base::Hash(policy->policy_value());
   bool changed = new_hash_value != policy_hash_value_;
   policy_hash_value_ = new_hash_value;
   return changed;
 }
 
-bool CloudPolicyInvalidator::IsInvalidationExpired(int64 version) {
+bool CloudPolicyInvalidator::IsInvalidationExpired(int64_t version) {
   base::Time last_fetch_time = base::Time::UnixEpoch() +
       base::TimeDelta::FromMilliseconds(core_->store()->policy()->timestamp());
 
   // If the version is unknown, consider the invalidation invalid if the
   // policy was fetched very recently.
   if (version < 0) {
     base::TimeDelta elapsed = clock_->Now() - last_fetch_time;
     return elapsed.InSeconds() < kUnknownVersionIgnorePeriod;
   }
 
@@ skipping 35 matching lines @@
 bool CloudPolicyInvalidator::GetInvalidationsEnabled() {
   if (!invalidations_enabled_)
     return false;
   // If invalidations have been enabled for less than the grace period, then
   // consider invalidations to be disabled for metrics reporting.
   base::TimeDelta elapsed = clock_->Now() - invalidations_enabled_time_;
   return elapsed.InSeconds() >= kInvalidationGracePeriod;
 }
 
 }  // namespace policy