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

components/drive/service/fake_drive_service.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 "components/drive/service/fake_drive_service.h"
 
+#include <stddef.h>
+
 #include <string>
 
 #include "base/files/file_util.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/logging.h"
 #include "base/md5.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
@@ skipping 77 matching lines @@
       return false;
     // Search query in the title.
     if (!entry.file() ||
         entry.file()->title().find(value) == std::string::npos)
       return false;
   }
   return true;
 }
 
 void ScheduleUploadRangeCallback(const UploadRangeCallback& callback,
-                                 int64 start_position,
-                                 int64 end_position,
+                                 int64_t start_position,
+                                 int64_t end_position,
                                  DriveApiErrorCode error,
                                  scoped_ptr<FileResource> entry) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback,
                  UploadRangeResponse(error,
                                      start_position,
                                      end_position),
                  base::Passed(&entry)));
 }
@@ skipping 47 matching lines @@
           /* end position */ content_length,
           content_length,
           content_type,
           local_file_path,
           base::Bind(&CallFileResouceCallback, callback),
           progress_callback);
     }
   }
 
   base::WeakPtr<FakeDriveService> service;
-  int64 content_length;
+  int64_t content_length;
   std::string content_type;
   base::FilePath local_file_path;
   FileResourceCallback callback;
   ProgressCallback progress_callback;
 };
 
 }  // namespace
 
 struct FakeDriveService::EntryInfo {
   EntryInfo()
       : user_permission(google_apis::drive::PERMISSION_ROLE_OWNER),
         visibility(google_apis::drive::FILE_VISIBILITY_DEFAULT) {}
 
   google_apis::ChangeResource change_resource;
   GURL share_url;
   std::string content_data;
 
   // Behaves in the same way as "userPermission" described in
   // https://developers.google.com/drive/v2/reference/files
   google_apis::drive::PermissionRole user_permission;
 
   google_apis::drive::FileVisibility visibility;
 };
 
 struct FakeDriveService::UploadSession {
   std::string content_type;
-  int64 content_length;
+  int64_t content_length;
   std::string parent_resource_id;
   std::string resource_id;
   std::string etag;
   std::string title;
 
-  int64 uploaded_size;
+  int64_t uploaded_size;
 
   UploadSession()
       : content_length(0),
         uploaded_size(0) {}
 
-  UploadSession(
-      std::string content_type,
-      int64 content_length,
-      std::string parent_resource_id,
-      std::string resource_id,
-      std::string etag,
-      std::string title)
-    : content_type(content_type),
-      content_length(content_length),
-      parent_resource_id(parent_resource_id),
-      resource_id(resource_id),
-      etag(etag),
-      title(title),
-      uploaded_size(0) {
-  }
+  UploadSession(std::string content_type,
+                int64_t content_length,
+                std::string parent_resource_id,
+                std::string resource_id,
+                std::string etag,
+                std::string title)
+      : content_type(content_type),
+        content_length(content_length),
+        parent_resource_id(parent_resource_id),
+        resource_id(resource_id),
+        etag(etag),
+        title(title),
+        uploaded_size(0) {}
 };
 
 FakeDriveService::FakeDriveService()
     : about_resource_(new AboutResource),
       published_date_seq_(0),
       next_upload_sequence_number_(0),
       default_max_results_(0),
       resource_id_count_(0),
       file_list_load_count_(0),
       change_list_load_count_(0),
@@ skipping 83 matching lines @@
     std::string item_id;
     if (item->GetStringWithoutPathExpansion(kKeyId, &item_id) &&
         item_id == app_id) {
       return true;
     }
   }
 
   return false;
 }
 
-void FakeDriveService::SetQuotaValue(int64 used, int64 total) {
+void FakeDriveService::SetQuotaValue(int64_t used, int64_t total) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   about_resource_->set_quota_bytes_used_aggregate(used);
   about_resource_->set_quota_bytes_total(total);
 }
 
 GURL FakeDriveService::GetFakeLinkUrl(const std::string& resource_id) {
   return GURL("https://fake_server/" + net::EscapePath(resource_id));
 }
 
@@ skipping 110 matching lines @@
                         base::StringPrintf("title:'%s'", title.c_str()),
                         directory_resource_id,
                         0,  // start offset
                         default_max_results_,
                         NULL,
                         base::Bind(&FileListCallbackAdapter, callback));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::GetChangeList(
-    int64 start_changestamp,
+    int64_t start_changestamp,
     const ChangeListCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   GetChangeListInternal(start_changestamp,
                         std::string(),  // empty search query
                         std::string(),  // no directory resource id,
                         0,  // start offset
                         default_max_results_,
                         &change_list_load_count_,
                         callback);
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::GetRemainingChangeList(
     const GURL& next_link,
     const ChangeListCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!next_link.is_empty());
   DCHECK(!callback.is_null());
 
   // "changestamp", "q", "parent" and "start-offset" are parameters to
   // implement "paging" of the result on FakeDriveService.
   // The URL should be the one filled in GetChangeListInternal of the
   // previous method invocation, so it should start with "http://localhost/?".
   // See also GetChangeListInternal.
   DCHECK_EQ(next_link.host(), "localhost");
   DCHECK_EQ(next_link.path(), "/");
 
-  int64 start_changestamp = 0;
+  int64_t start_changestamp = 0;
   std::string search_query;
   std::string directory_resource_id;
   int start_offset = 0;
   int max_results = default_max_results_;
   base::StringPairs parameters;
   if (base::SplitStringIntoKeyValuePairs(
           next_link.query(), '=', '&', &parameters)) {
     for (size_t i = 0; i < parameters.size(); ++i) {
       if (parameters[i].first == "changestamp") {
         base::StringToInt64(parameters[i].second, &start_changestamp);
@@ skipping 253 matching lines @@
   EntryInfo* entry = FindEntryByResourceId(resource_id);
   if (!entry || entry->change_resource.file()->IsHostedDocument()) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(download_action_callback, HTTP_NOT_FOUND, base::FilePath()));
     return CancelCallback();
   }
 
   const FileResource* file = entry->change_resource.file();
   const std::string& content_data = entry->content_data;
-  int64 file_size = file->file_size();
+  int64_t file_size = file->file_size();
   DCHECK_EQ(static_cast<size_t>(file_size), content_data.size());
 
   if (!get_content_callback.is_null()) {
-    const int64 kBlockSize = 5;
-    for (int64 i = 0; i < file_size; i += kBlockSize) {
-      const int64 size = std::min(kBlockSize, file_size - i);
+    const int64_t kBlockSize = 5;
+    for (int64_t i = 0; i < file_size; i += kBlockSize) {
+      const int64_t size = std::min(kBlockSize, file_size - i);
       scoped_ptr<std::string> content_for_callback(
           new std::string(content_data.substr(i, size)));
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE,
           base::Bind(get_content_callback, HTTP_SUCCESS,
                      base::Passed(&content_for_callback)));
     }
   }
 
   if (!test_util::WriteStringToFile(local_cache_path, content_data)) {
@@ skipping 258 matching lines @@
   return AddNewDirectoryWithResourceId(
       "",
       parent_resource_id.empty() ? GetRootResourceId() : parent_resource_id,
       directory_title,
       options,
       callback);
 }
 
 CancelCallback FakeDriveService::InitiateUploadNewFile(
     const std::string& content_type,
-    int64 content_length,
+    int64_t content_length,
     const std::string& parent_resource_id,
     const std::string& title,
     const UploadNewFileOptions& options,
     const InitiateUploadCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (offline_) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
@@ skipping 18 matching lines @@
                     title);
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback, HTTP_SUCCESS, session_url));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::InitiateUploadExistingFile(
     const std::string& content_type,
-    int64 content_length,
+    int64_t content_length,
     const std::string& resource_id,
     const UploadExistingFileOptions& options,
     const InitiateUploadCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   if (offline_) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback, DRIVE_NO_CONNECTION, GURL()));
@@ skipping 33 matching lines @@
                     "" /* title */);
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback, HTTP_SUCCESS, session_url));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::GetUploadStatus(
     const GURL& upload_url,
-    int64 content_length,
+    int64_t content_length,
     const UploadRangeCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::ResumeUpload(
-      const GURL& upload_url,
-      int64 start_position,
-      int64 end_position,
-      int64 content_length,
-      const std::string& content_type,
-      const base::FilePath& local_file_path,
-      const UploadRangeCallback& callback,
-      const ProgressCallback& progress_callback) {
+    const GURL& upload_url,
+    int64_t start_position,
+    int64_t end_position,
+    int64_t content_length,
+    const std::string& content_type,
+    const base::FilePath& local_file_path,
+    const UploadRangeCallback& callback,
+    const ProgressCallback& progress_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   FileResourceCallback completion_callback
       = base::Bind(&ScheduleUploadRangeCallback,
                    callback, start_position, end_position);
 
   if (offline_) {
     completion_callback.Run(DRIVE_NO_CONNECTION, scoped_ptr<FileResource>());
     return CancelCallback();
@@ skipping 13 matching lines @@
     return CancelCallback();
   }
 
   if (!progress_callback.is_null()) {
     // In the real GDataWapi/Drive DriveService, progress is reported in
     // nondeterministic timing. In this fake implementation, we choose to call
     // it twice per one ResumeUpload. This is for making sure that client code
     // works fine even if the callback is invoked more than once; it is the
     // crucial difference of the progress callback from others.
     // Note that progress is notified in the relative offset in each chunk.
-    const int64 chunk_size = end_position - start_position;
+    const int64_t chunk_size = end_position - start_position;
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(progress_callback, chunk_size / 2, chunk_size));
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(progress_callback, chunk_size, chunk_size));
   }
 
   if (content_length != end_position) {
     session->uploaded_size = end_position;
     completion_callback.Run(HTTP_RESUME_INCOMPLETE, scoped_ptr<FileResource>());
     return CancelCallback();
@@ skipping 55 matching lines @@
       new FileResource(*file)));
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&FakeDriveService::NotifyObservers,
                  weak_ptr_factory_.GetWeakPtr()));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::MultipartUploadNewFile(
     const std::string& content_type,
-    int64 content_length,
+    int64_t content_length,
     const std::string& parent_resource_id,
     const std::string& title,
     const base::FilePath& local_file_path,
     const UploadNewFileOptions& options,
     const FileResourceCallback& callback,
     const ProgressCallback& progress_callback) {
   CallResumeUpload* const call_resume_upload = new CallResumeUpload();
   call_resume_upload->service = weak_ptr_factory_.GetWeakPtr();
   call_resume_upload->content_type = content_type;
   call_resume_upload->content_length = content_length;
   call_resume_upload->local_file_path = local_file_path;
   call_resume_upload->callback = callback;
   call_resume_upload->progress_callback = progress_callback;
   InitiateUploadNewFile(
       content_type,
       content_length,
       parent_resource_id,
       title,
       options,
       base::Bind(&CallResumeUpload::Run, base::Owned(call_resume_upload)));
   return CancelCallback();
 }
 
 CancelCallback FakeDriveService::MultipartUploadExistingFile(
     const std::string& content_type,
-    int64 content_length,
+    int64_t content_length,
     const std::string& resource_id,
     const base::FilePath& local_file_path,
     const UploadExistingFileOptions& options,
     const FileResourceCallback& callback,
     const ProgressCallback& progress_callback) {
   CallResumeUpload* const call_resume_upload = new CallResumeUpload();
   call_resume_upload->service = weak_ptr_factory_.GetWeakPtr();
   call_resume_upload->content_type = content_type;
   call_resume_upload->content_length = content_length;
   call_resume_upload->local_file_path = local_file_path;
@@ skipping 355 matching lines @@
   base::Time published_date =
       base::Time() + base::TimeDelta::FromMilliseconds(++published_date_seq_);
   new_file->set_created_date(published_date);
 
   EntryInfo* raw_new_entry = new_entry.release();
   entries_[resource_id] = raw_new_entry;
   return raw_new_entry;
 }
 
 void FakeDriveService::GetChangeListInternal(
-    int64 start_changestamp,
+    int64_t start_changestamp,
     const std::string& search_query,
     const std::string& directory_resource_id,
     int start_offset,
     int max_results,
     int* load_counter,
     const ChangeListCallback& callback) {
   if (offline_) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback,
@@ skipping 133 matching lines @@
 
   NOTREACHED();
   return scoped_ptr<BatchRequestConfiguratorInterface>();
 }
 
 void FakeDriveService::NotifyObservers() {
   FOR_EACH_OBSERVER(ChangeObserver, change_observers_, OnNewChangeAvailable());
 }
 
 }  // namespace drive