Switch to standard integer types in chrome/browser/chromeos/.

chrome/browser/chromeos/policy/auto_enrollment_client.cc

 // Copyright (c) 2012 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/chromeos/policy/auto_enrollment_client.h"
 
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/guid.h"
@@ skipping 25 matching lines @@
 namespace {
 
 // UMA histogram names.
 const char kUMAProtocolTime[] = "Enterprise.AutoEnrollmentProtocolTime";
 const char kUMAExtraTime[] = "Enterprise.AutoEnrollmentExtraTime";
 const char kUMARequestStatus[] = "Enterprise.AutoEnrollmentRequestStatus";
 const char kUMANetworkErrorCode[] =
     "Enterprise.AutoEnrollmentRequestNetworkErrorCode";
 
 // Returns the power of the next power-of-2 starting at |value|.
-int NextPowerOf2(int64 value) {
+int NextPowerOf2(int64_t value) {
   for (int i = 0; i <= AutoEnrollmentClient::kMaximumPower; ++i) {
     if ((INT64_C(1) << i) >= value)
       return i;
   }
-  // No other value can be represented in an int64.
+  // No other value can be represented in an int64_t.
   return AutoEnrollmentClient::kMaximumPower + 1;
 }
 
 // Sets or clears a value in a dictionary.
 void UpdateDict(base::DictionaryValue* dict,
                 const char* pref_path,
                 bool set_or_clear,
                 base::Value* value) {
   scoped_ptr<base::Value> scoped_value(value);
   if (set_or_clear)
@@ skipping 167 matching lines @@
          restore_mode == RESTORE_MODE_REENROLLMENT_ENFORCED);
 
     ReportProgress(trigger_enrollment ? AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT
                                       : AUTO_ENROLLMENT_STATE_NO_ENROLLMENT);
   }
 }
 
 void AutoEnrollmentClient::SendBucketDownloadRequest() {
   // Only power-of-2 moduli are supported for now. These are computed by taking
   // the lower |current_power_| bits of the hash.
-  uint64 remainder = 0;
+  uint64_t remainder = 0;
   for (int i = 0; 8 * i < current_power_; ++i) {
-    uint64 byte = server_backed_state_key_hash_[31 - i] & 0xff;
+    uint64_t byte = server_backed_state_key_hash_[31 - i] & 0xff;
     remainder = remainder | (byte << (8 * i));
   }
   remainder = remainder & ((UINT64_C(1) << current_power_) - 1);
 
   ReportProgress(AUTO_ENROLLMENT_STATE_PENDING);
 
   request_job_.reset(
       device_management_service_->CreateJob(
           DeviceManagementRequestJob::TYPE_AUTO_ENROLLMENT,
           request_context_.get()));
@@ skipping 62 matching lines @@
     const em::DeviceManagementResponse& response) {
   bool progress = false;
   const em::DeviceAutoEnrollmentResponse& enrollment_response =
       response.auto_enrollment_response();
   if (!response.has_auto_enrollment_response()) {
     LOG(ERROR) << "Server failed to provide auto-enrollment response.";
   } else if (enrollment_response.has_expected_modulus()) {
     // Server is asking us to retry with a different modulus.
     modulus_updates_received_++;
 
-    int64 modulus = enrollment_response.expected_modulus();
+    int64_t modulus = enrollment_response.expected_modulus();
     int power = NextPowerOf2(modulus);
     if ((INT64_C(1) << power) != modulus) {
       LOG(ERROR) << "Auto enrollment: the server didn't ask for a power-of-2 "
                  << "modulus. Using the closest power-of-2 instead "
                  << "(" << modulus << " vs 2^" << power << ")";
     }
     if (modulus_updates_received_ >= 2) {
       LOG(ERROR) << "Auto enrollment error: already retried with an updated "
                  << "modulus but the server asked for a new one again: "
                  << power;
@@ skipping 94 matching lines @@
   base::TimeDelta delta = kZero;
   if (!time_extra_start_.is_null())
     delta = now - time_extra_start_;
   // This samples |kZero| when there was no need for extra time, so that we can
   // measure the ratio of users that succeeded without needing a delay to the
   // total users going through OOBE.
   UMA_HISTOGRAM_CUSTOM_TIMES(kUMAExtraTime, delta, kMin, kMax, kBuckets);
 }
 
 }  // namespace policy