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

chrome/browser/android/history_report/usage_reports_buffer_service.cc

 // Copyright 2015 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/android/history_report/usage_reports_buffer_service.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/synchronization/waitable_event.h"
 #include "chrome/browser/android/history_report/usage_reports_buffer_backend.h"
 #include "chrome/browser/android/proto/delta_file.pb.h"
 #include "content/public/browser/browser_thread.h"
 
 
 namespace {
 
 void DoInit(history_report::UsageReportsBufferBackend* backend) {
   backend->Init();
 }
 
 void DoAddVisit(history_report::UsageReportsBufferBackend* backend,
                 const std::string id,
-                int64 timestamp_ms,
+                int64_t timestamp_ms,
                 bool typed_visit) {
   backend->AddVisit(id, timestamp_ms, typed_visit);
 }
 
 void DoRemove(history_report::UsageReportsBufferBackend* backend,
               const std::vector<std::string>* reports,
               base::WaitableEvent* finished) {
   backend->Remove(*reports);
   finished->Signal();
 }
 
 void DoGetUsageReportsBatch(
     history_report::UsageReportsBufferBackend* backend,
-    int32 batch_size,
+    int32_t batch_size,
     base::WaitableEvent* finished,
-    scoped_ptr<std::vector<history_report::UsageReport> >* result) {
+    scoped_ptr<std::vector<history_report::UsageReport>>* result) {
   *result = backend->GetUsageReportsBatch(batch_size).Pass();
   finished->Signal();
 }
 
 void DoClear(
     history_report::UsageReportsBufferBackend* backend,
     base::WaitableEvent* finished) {
   backend->Clear();
   finished->Signal();
 }
@@ skipping 22 matching lines @@
 void UsageReportsBufferService::Init() {
   base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
   pool->PostSequencedWorkerTaskWithShutdownBehavior(
       worker_pool_token_,
       FROM_HERE,
       base::Bind(&DoInit, base::Unretained(backend_.get())),
       base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
 }
 
 void UsageReportsBufferService::AddVisit(const std::string& id,
-    int64 timestamp_ms,
-    bool typed_visit) {
+                                         int64_t timestamp_ms,
+                                         bool typed_visit) {
   base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
   pool->PostSequencedWorkerTaskWithShutdownBehavior(
       worker_pool_token_,
       FROM_HERE,
       base::Bind(&DoAddVisit,
                  base::Unretained(backend_.get()),
                  id,
                  timestamp_ms,
                  typed_visit),
       base::SequencedWorkerPool::BLOCK_SHUTDOWN);
 }
 
-scoped_ptr<std::vector<UsageReport> >
-UsageReportsBufferService::GetUsageReportsBatch(int32 batch_size) {
+scoped_ptr<std::vector<UsageReport>>
+UsageReportsBufferService::GetUsageReportsBatch(int32_t batch_size) {
   scoped_ptr<std::vector<UsageReport> > result;
   base::WaitableEvent finished(false, false);
   base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
   // It's ok to pass unretained pointers here because this is a synchronous
   // call.
   pool->PostSequencedWorkerTaskWithShutdownBehavior(
       worker_pool_token_,
       FROM_HERE,
       base::Bind(&DoGetUsageReportsBatch,
                  base::Unretained(backend_.get()),
@@ skipping 49 matching lines @@
       base::Bind(&DoDump,
                  base::Unretained(backend_.get()),
                  base::Unretained(&finished),
                  base::Unretained(&dump)),
       base::SequencedWorkerPool::BLOCK_SHUTDOWN);
   finished.Wait();
   return dump;
 }
 
 }  // namespace history_report