Switch to standard integer types in components/, part 2 of 4.

components/history/core/browser/delete_directive_handler.cc

 // Copyright (c) 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 "components/history/core/browser/delete_directive_handler.h"
 
+#include <stddef.h>
+
 #include "base/json/json_writer.h"
 #include "base/rand_util.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "components/history/core/browser/history_backend.h"
 #include "components/history/core/browser/history_db_task.h"
 #include "components/history/core/browser/history_service.h"
 #include "sync/api/sync_change.h"
 #include "sync/protocol/history_delete_directive_specifics.pb.h"
 #include "sync/protocol/proto_value_conversions.h"
@@ skipping 27 matching lines @@
   const sync_pb::TimeRangeDirective& range2 =
       data2.GetSpecifics().history_delete_directive().time_range_directive();
   if (range1.start_time_usec() < range2.start_time_usec())
     return true;
   if (range1.start_time_usec() > range2.start_time_usec())
     return false;
   return range1.end_time_usec() < range2.end_time_usec();
 }
 
 // Converts a Unix timestamp in microseconds to a base::Time value.
-base::Time UnixUsecToTime(int64 usec) {
+base::Time UnixUsecToTime(int64_t usec) {
   return base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(usec);
 }
 
 // Converts a base::Time value to a Unix timestamp in microseconds.
-int64 TimeToUnixUsec(base::Time time) {
+int64_t TimeToUnixUsec(base::Time time) {
   DCHECK(!time.is_null());
   return (time - base::Time::UnixEpoch()).InMicroseconds();
 }
 
 // Converts global IDs in |global_id_directive| to times.
 void GetTimesFromGlobalIds(
     const sync_pb::GlobalIdDirective& global_id_directive,
     std::set<base::Time>* times) {
   for (int i = 0; i < global_id_directive.global_id_size(); ++i) {
     times->insert(
@@ skipping 234 matching lines @@
         &internal_tracker_);
   }
 }
 
 void DeleteDirectiveHandler::Stop() {
   DCHECK(thread_checker_.CalledOnValidThread());
   sync_processor_.reset();
 }
 
 bool DeleteDirectiveHandler::CreateDeleteDirectives(
-    const std::set<int64>& global_ids,
+    const std::set<int64_t>& global_ids,
     base::Time begin_time,
     base::Time end_time) {
   base::Time now = base::Time::Now();
   sync_pb::HistoryDeleteDirectiveSpecifics delete_directive;
 
   // Delete directives require a non-null begin time, so use 1 if it's null.
-  int64 begin_time_usecs =
+  int64_t begin_time_usecs =
       begin_time.is_null() ? 0 : TimeToUnixUsec(begin_time);
 
   // Determine the actual end time -- it should not be null or in the future.
   // TODO(dubroy): Use sane time (crbug.com/146090) here when it's available.
   base::Time end = (end_time.is_null() || end_time > now) ? now : end_time;
   // -1 because end time in delete directives is inclusive.
-  int64 end_time_usecs = TimeToUnixUsec(end) - 1;
+  int64_t end_time_usecs = TimeToUnixUsec(end) - 1;
 
   if (global_ids.empty()) {
     sync_pb::TimeRangeDirective* time_range_directive =
         delete_directive.mutable_time_range_directive();
     time_range_directive->set_start_time_usec(begin_time_usecs);
     time_range_directive->set_end_time_usec(end_time_usecs);
   } else {
-    for (std::set<int64>::const_iterator it = global_ids.begin();
+    for (std::set<int64_t>::const_iterator it = global_ids.begin();
          it != global_ids.end(); ++it) {
       sync_pb::GlobalIdDirective* global_id_directive =
           delete_directive.mutable_global_id_directive();
       global_id_directive->add_global_id(*it);
       global_id_directive->set_start_time_usec(begin_time_usecs);
       global_id_directive->set_end_time_usec(end_time_usecs);
     }
   }
   syncer::SyncError error = ProcessLocalDeleteDirective(delete_directive);
   return !error.IsSet();
@@ skipping 76 matching lines @@
     syncer::SyncChangeList change_list;
     for (size_t i = 0; i < delete_directives.size(); ++i) {
       change_list.push_back(syncer::SyncChange(
           FROM_HERE, syncer::SyncChange::ACTION_DELETE, delete_directives[i]));
     }
     sync_processor_->ProcessSyncChanges(FROM_HERE, change_list);
   }
 }
 
 }  // namespace history