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

chrome/browser/sync_file_system/local/canned_syncable_file_system.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/sync_file_system/local/canned_syncable_file_system.h"
 
+#include <stddef.h>
+
 #include <algorithm>
 #include <iterator>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/guid.h"
+#include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "chrome/browser/sync_file_system/file_change.h"
 #include "chrome/browser/sync_file_system/local/local_file_change_tracker.h"
 #include "chrome/browser/sync_file_system/local/local_file_sync_context.h"
 #include "chrome/browser/sync_file_system/local/sync_file_system_backend.h"
 #include "chrome/browser/sync_file_system/syncable_file_system_util.h"
@@ skipping 136 matching lines @@
 
   ~WriteHelper() {
     if (request_context_) {
       base::ThreadTaskRunnerHandle::Get()->DeleteSoon(
           FROM_HERE, request_context_.release());
     }
   }
 
   ScopedTextBlob* scoped_text_blob() const { return blob_data_.get(); }
 
-  void DidWrite(const base::Callback<void(int64 result)>& completion_callback,
-                File::Error error, int64 bytes, bool complete) {
+  void DidWrite(const base::Callback<void(int64_t result)>& completion_callback,
+                File::Error error,
+                int64_t bytes,
+                bool complete) {
     if (error == base::File::FILE_OK) {
       bytes_written_ += bytes;
       if (!complete)
         return;
     }
-    completion_callback.Run(error == base::File::FILE_OK ?
-                            bytes_written_ : static_cast<int64>(error));
+    completion_callback.Run(error == base::File::FILE_OK
+                                ? bytes_written_
+                                : static_cast<int64_t>(error));
   }
 
  private:
-  int64 bytes_written_;
+  int64_t bytes_written_;
   scoped_ptr<MockBlobURLRequestContext> request_context_;
   scoped_ptr<ScopedTextBlob> blob_data_;
 
   DISALLOW_COPY_AND_ASSIGN(WriteHelper);
 };
 
 void DidGetUsageAndQuota(const storage::StatusCallback& callback,
-                         int64* usage_out,
-                         int64* quota_out,
+                         int64_t* usage_out,
+                         int64_t* quota_out,
                          storage::QuotaStatusCode status,
-                         int64 usage,
-                         int64 quota) {
+                         int64_t usage,
+                         int64_t quota) {
   *usage_out = usage;
   *quota_out = quota;
   callback.Run(status);
 }
 
 void EnsureLastTaskRuns(base::SingleThreadTaskRunner* runner) {
   base::RunLoop run_loop;
   runner->PostTaskAndReply(
       FROM_HERE, base::Bind(&base::DoNothing), run_loop.QuitClosure());
   run_loop.Run();
@@ skipping 160 matching lines @@
 File::Error CannedSyncableFileSystem::Move(
     const FileSystemURL& src_url, const FileSystemURL& dest_url) {
   return RunOnThread<File::Error>(io_task_runner_.get(),
                                   FROM_HERE,
                                   base::Bind(&CannedSyncableFileSystem::DoMove,
                                              base::Unretained(this),
                                              src_url,
                                              dest_url));
 }
 
-File::Error CannedSyncableFileSystem::TruncateFile(
-    const FileSystemURL& url, int64 size) {
+File::Error CannedSyncableFileSystem::TruncateFile(const FileSystemURL& url,
+                                                   int64_t size) {
   return RunOnThread<File::Error>(
       io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoTruncateFile,
                  base::Unretained(this),
                  url,
                  size));
 }
 
 File::Error CannedSyncableFileSystem::TouchFile(
@@ skipping 72 matching lines @@
     FileEntryList* entries) {
   return RunOnThread<File::Error>(
       io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoReadDirectory,
                  base::Unretained(this),
                  url,
                  entries));
 }
 
-int64 CannedSyncableFileSystem::Write(
+int64_t CannedSyncableFileSystem::Write(
     net::URLRequestContext* url_request_context,
     const FileSystemURL& url,
     scoped_ptr<storage::BlobDataHandle> blob_data_handle) {
-  return RunOnThread<int64>(io_task_runner_.get(),
-                            FROM_HERE,
-                            base::Bind(&CannedSyncableFileSystem::DoWrite,
-                                       base::Unretained(this),
-                                       url_request_context,
-                                       url,
-                                       base::Passed(&blob_data_handle)));
+  return RunOnThread<int64_t>(
+      io_task_runner_.get(), FROM_HERE,
+      base::Bind(&CannedSyncableFileSystem::DoWrite, base::Unretained(this),
+                 url_request_context, url, base::Passed(&blob_data_handle)));
 }
 
-int64 CannedSyncableFileSystem::WriteString(
-    const FileSystemURL& url, const std::string& data) {
-  return RunOnThread<int64>(io_task_runner_.get(),
-                            FROM_HERE,
-                            base::Bind(&CannedSyncableFileSystem::DoWriteString,
-                                       base::Unretained(this),
-                                       url,
-                                       data));
+int64_t CannedSyncableFileSystem::WriteString(const FileSystemURL& url,
+                                              const std::string& data) {
+  return RunOnThread<int64_t>(
+      io_task_runner_.get(), FROM_HERE,
+      base::Bind(&CannedSyncableFileSystem::DoWriteString,
+                 base::Unretained(this), url, data));
 }
 
 File::Error CannedSyncableFileSystem::DeleteFileSystem() {
   EXPECT_TRUE(is_filesystem_set_up_);
   return RunOnThread<File::Error>(
       io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&FileSystemContext::DeleteFileSystem,
                  file_system_context_,
                  origin_,
                  type_));
 }
 
 storage::QuotaStatusCode CannedSyncableFileSystem::GetUsageAndQuota(
-    int64* usage,
-    int64* quota) {
+    int64_t* usage,
+    int64_t* quota) {
   return RunOnThread<storage::QuotaStatusCode>(
       io_task_runner_.get(),
       FROM_HERE,
       base::Bind(&CannedSyncableFileSystem::DoGetUsageAndQuota,
                  base::Unretained(this),
                  usage,
                  quota));
 }
 
 void CannedSyncableFileSystem::GetChangedURLsInTracker(
@@ skipping 86 matching lines @@
 void CannedSyncableFileSystem::DoMove(
     const FileSystemURL& src_url,
     const FileSystemURL& dest_url,
     const StatusCallback& callback) {
   EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
   EXPECT_TRUE(is_filesystem_opened_);
   operation_runner()->Move(
       src_url, dest_url, storage::FileSystemOperation::OPTION_NONE, callback);
 }
 
-void CannedSyncableFileSystem::DoTruncateFile(
-    const FileSystemURL& url, int64 size,
-    const StatusCallback& callback) {
+void CannedSyncableFileSystem::DoTruncateFile(const FileSystemURL& url,
+                                              int64_t size,
+                                              const StatusCallback& callback) {
   EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
   EXPECT_TRUE(is_filesystem_opened_);
   operation_runner()->Truncate(url, size, callback);
 }
 
 void CannedSyncableFileSystem::DoTouchFile(
     const FileSystemURL& url,
     const base::Time& last_access_time,
     const base::Time& last_modified_time,
     const StatusCallback& callback) {
@@ skipping 80 matching lines @@
   MockBlobURLRequestContext* url_request_context(
       new MockBlobURLRequestContext(file_system_context_.get()));
   WriteHelper* helper = new WriteHelper(url_request_context, data);
   operation_runner()->Write(url_request_context, url,
                             helper->scoped_text_blob()->GetBlobDataHandle(), 0,
                             base::Bind(&WriteHelper::DidWrite,
                                        base::Owned(helper), callback));
 }
 
 void CannedSyncableFileSystem::DoGetUsageAndQuota(
-    int64* usage,
-    int64* quota,
+    int64_t* usage,
+    int64_t* quota,
     const storage::StatusCallback& callback) {
   // crbug.com/349708
   TRACE_EVENT0("io", "CannedSyncableFileSystem::DoGetUsageAndQuota");
 
   EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
   EXPECT_TRUE(is_filesystem_opened_);
   DCHECK(quota_manager_.get());
   quota_manager_->GetUsageAndQuota(
       origin_, storage_type(),
       base::Bind(&DidGetUsageAndQuota, callback, usage, quota));
@@ skipping 31 matching lines @@
   sync_status_ = status;
   quit_closure.Run();
 }
 
 void CannedSyncableFileSystem::InitializeSyncStatusObserver() {
   ASSERT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
   backend()->sync_context()->sync_status()->AddObserver(this);
 }
 
 }  // namespace sync_file_system