Switch to standard integer types in components/policy/.

components/policy/core/common/cloud/cloud_policy_client.h

 // 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.
 
 #ifndef COMPONENTS_POLICY_CORE_COMMON_CLOUD_CLOUD_POLICY_CLIENT_H_
 #define COMPONENTS_POLICY_CORE_COMMON_CLOUD_CLOUD_POLICY_CLIENT_H_
 
+#include <stdint.h>
+
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/callback.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/observer_list.h"
 #include "base/time/time.h"
 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
 #include "components/policy/core/common/remote_commands/remote_command_job.h"
 #include "components/policy/policy_export.h"
 #include "policy/proto/device_management_backend.pb.h"
 
 namespace net {
@@ skipping 75 matching lines @@
       enterprise_management::DeviceRegisterRequest::Type registration_type,
       enterprise_management::DeviceRegisterRequest::Flavor flavor,
       const std::string& auth_token,
       const std::string& client_id,
       const std::string& requisition,
       const std::string& current_state_key);
 
   // Sets information about a policy invalidation. Subsequent fetch operations
   // will use the given info, and callers can use fetched_invalidation_version
   // to determine which version of policy was fetched.
-  void SetInvalidationInfo(int64 version, const std::string& payload);
+  void SetInvalidationInfo(int64_t version, const std::string& payload);
 
   // Requests a policy fetch. The client being registered is a prerequisite to
   // this operation and this call will CHECK if the client is not in registered
   // state. FetchPolicy() triggers a policy fetch from the cloud. A policy
   // change notification is reported to the observers and the new policy blob
   // can be retrieved once the policy fetch operation completes. In case of
   // multiple requests to fetch policy, new requests will cancel any pending
   // requests and the latest request will eventually trigger notifications.
   virtual void FetchPolicy();
 
@@ skipping 122 matching lines @@
     return status_;
   }
 
   const std::string& robot_api_auth_code() const {
     return robot_api_auth_code_;
   }
 
   // Returns the invalidation version that was used for the last FetchPolicy.
   // Observers can call this method from their OnPolicyFetched method to
   // determine which at which invalidation version the policy was fetched.
-  int64 fetched_invalidation_version() const {
+  int64_t fetched_invalidation_version() const {
     return fetched_invalidation_version_;
   }
 
   scoped_refptr<net::URLRequestContextGetter> GetRequestContext();
 
   // Returns the number of active requests.
   int GetActiveRequestCountForTest() const;
 
  protected:
   // A set of (policy type, settings entity ID) pairs to fetch.
@@ skipping 93 matching lines @@
   std::string dm_token_;
   DeviceMode device_mode_;
   std::string client_id_;
   bool submit_machine_id_;
   base::Time last_policy_timestamp_;
   int public_key_version_;
   bool public_key_version_valid_;
   std::string robot_api_auth_code_;
 
   // Information for the latest policy invalidation received.
-  int64 invalidation_version_;
+  int64_t invalidation_version_;
   std::string invalidation_payload_;
 
   // The invalidation version used for the most recent fetch operation.
-  int64 fetched_invalidation_version_;
+  int64_t fetched_invalidation_version_;
 
   // Used for issuing requests to the cloud.
   DeviceManagementService* service_;
 
   // Only one outstanding policy fetch is allowed, so this is tracked in
   // its own member variable.
   scoped_ptr<DeviceManagementRequestJob> policy_fetch_request_job_;
 
   // All of the outstanding non-policy-fetch request jobs. These jobs are
   // silently cancelled if Unregister() is called.
   ScopedVector<DeviceManagementRequestJob> request_jobs_;
 
   // The policy responses returned by the last policy fetch operation.
   ResponseMap responses_;
   DeviceManagementStatus status_;
 
   base::ObserverList<Observer, true> observers_;
   scoped_refptr<net::URLRequestContextGetter> request_context_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CloudPolicyClient);
 };
 
 }  // namespace policy
 
 #endif  // COMPONENTS_POLICY_CORE_COMMON_CLOUD_CLOUD_POLICY_CLIENT_H_