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

components/drive/change_list_loader.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/change_list_loader.h"
 
+#include <stddef.h>
+
 #include <set>
 
 #include "base/callback.h"
 #include "base/callback_helpers.h"
+#include "base/macros.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/synchronization/cancellation_flag.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "components/drive/change_list_loader_observer.h"
 #include "components/drive/change_list_processor.h"
 #include "components/drive/event_logger.h"
 #include "components/drive/file_system_core_util.h"
 #include "components/drive/job_scheduler.h"
@@ skipping 76 matching lines @@
   ScopedVector<ChangeList> change_lists_;
   base::TimeTicks start_time_;
   base::ThreadChecker thread_checker_;
   base::WeakPtrFactory<FullFeedFetcher> weak_ptr_factory_;
   DISALLOW_COPY_AND_ASSIGN(FullFeedFetcher);
 };
 
 // Fetches the delta changes since |start_change_id|.
 class DeltaFeedFetcher : public ChangeListLoader::FeedFetcher {
  public:
-  DeltaFeedFetcher(JobScheduler* scheduler, int64 start_change_id)
+  DeltaFeedFetcher(JobScheduler* scheduler, int64_t start_change_id)
       : scheduler_(scheduler),
         start_change_id_(start_change_id),
-        weak_ptr_factory_(this) {
-  }
+        weak_ptr_factory_(this) {}
 
   ~DeltaFeedFetcher() override {}
 
   void Run(const FeedFetcherCallback& callback) override {
     DCHECK(thread_checker_.CalledOnValidThread());
     DCHECK(!callback.is_null());
 
     scheduler_->GetChangeList(
         start_change_id_,
         base::Bind(&DeltaFeedFetcher::OnChangeListFetched,
@@ skipping 25 matching lines @@
       return;
     }
 
     // Note: The fetcher is managed by ChangeListLoader, and the instance
     // will be deleted in the callback. Do not touch the fields after this
     // invocation.
     callback.Run(FILE_ERROR_OK, change_lists_.Pass());
   }
 
   JobScheduler* scheduler_;
-  int64 start_change_id_;
+  int64_t start_change_id_;
   ScopedVector<ChangeList> change_lists_;
   base::ThreadChecker thread_checker_;
   base::WeakPtrFactory<DeltaFeedFetcher> weak_ptr_factory_;
   DISALLOW_COPY_AND_ASSIGN(DeltaFeedFetcher);
 };
 
 }  // namespace
 
 LoaderController::LoaderController()
     : lock_count_(0),
@@ skipping 203 matching lines @@
   const bool is_initial_load = (!loaded_ && !IsRefreshing());
 
   // Register the callback function to be called when it is loaded.
   pending_load_callback_.push_back(callback);
 
   // If loading task is already running, do nothing.
   if (pending_load_callback_.size() > 1)
     return;
 
   // Check the current status of local metadata, and start loading if needed.
-  int64* local_changestamp = new int64(0);
+  int64_t* local_changestamp = new int64_t(0);
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&ResourceMetadata::GetLargestChangestamp,
                  base::Unretained(resource_metadata_),
                  local_changestamp),
       base::Bind(&ChangeListLoader::LoadAfterGetLargestChangestamp,
                  weak_ptr_factory_.GetWeakPtr(),
                  is_initial_load,
                  base::Owned(local_changestamp)));
 }
 
 void ChangeListLoader::LoadAfterGetLargestChangestamp(
     bool is_initial_load,
-    const int64* local_changestamp,
+    const int64_t* local_changestamp,
     FileError error) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (error != FILE_ERROR_OK) {
     OnChangeListLoadComplete(error);
     return;
   }
 
   if (is_initial_load && *local_changestamp > 0) {
     // The local data is usable. Flush callbacks to tell loading was successful.
     OnChangeListLoadComplete(FILE_ERROR_OK);
 
     // Continues to load from server in background.
     // Put dummy callbacks to indicate that fetching is still continuing.
     pending_load_callback_.push_back(
         base::Bind(&util::EmptyFileOperationCallback));
   }
 
   about_resource_loader_->GetAboutResource(
       base::Bind(&ChangeListLoader::LoadAfterGetAboutResource,
                  weak_ptr_factory_.GetWeakPtr(),
                  *local_changestamp));
 }
 
 void ChangeListLoader::LoadAfterGetAboutResource(
-    int64 local_changestamp,
+    int64_t local_changestamp,
     google_apis::DriveApiErrorCode status,
     scoped_ptr<google_apis::AboutResource> about_resource) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   FileError error = GDataToFileError(status);
   if (error != FILE_ERROR_OK) {
     OnChangeListLoadComplete(error);
     return;
   }
 
   DCHECK(about_resource);
 
-  int64 remote_changestamp = about_resource->largest_change_id();
-  int64 start_changestamp = local_changestamp > 0 ? local_changestamp + 1 : 0;
+  int64_t remote_changestamp = about_resource->largest_change_id();
+  int64_t start_changestamp = local_changestamp > 0 ? local_changestamp + 1 : 0;
   if (local_changestamp >= remote_changestamp) {
     if (local_changestamp > remote_changestamp) {
       LOG(WARNING) << "Local resource metadata is fresher than server, "
                    << "local = " << local_changestamp
                    << ", server = " << remote_changestamp;
     }
 
     // No changes detected, tell the client that the loading was successful.
     OnChangeListLoadComplete(FILE_ERROR_OK);
   } else {
@@ skipping 35 matching lines @@
     logger_->Log(logging::LOG_ERROR,
                  "Failed to update the about resource: %s",
                  google_apis::DriveApiErrorCodeToString(error).c_str());
     return;
   }
   logger_->Log(logging::LOG_INFO,
                "About resource updated to: %s",
                base::Int64ToString(resource->largest_change_id()).c_str());
 }
 
-void ChangeListLoader::LoadChangeListFromServer(int64 start_changestamp) {
+void ChangeListLoader::LoadChangeListFromServer(int64_t start_changestamp) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!change_feed_fetcher_);
   DCHECK(about_resource_loader_->cached_about_resource());
 
   bool is_delta_update = start_changestamp != 0;
 
   // Set up feed fetcher.
   if (is_delta_update) {
     change_feed_fetcher_.reset(
         new DeltaFeedFetcher(scheduler_, start_changestamp));
@@ skipping 73 matching lines @@
 
   OnChangeListLoadComplete(error);
 
   FOR_EACH_OBSERVER(ChangeListLoaderObserver,
                     observers_,
                     OnLoadFromServerComplete());
 }
 
 }  // namespace internal
 }  // namespace drive