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

components/offline_pages/offline_page_model.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 "components/offline_pages/offline_page_model.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 67 matching lines @@
   for (const auto& file_path : paths_to_delete) {
     // Make sure delete happens on the left of || so that it is always executed.
     *success = base::DeleteFile(file_path, false) || *success;
   }
 }
 
 void EmptyDeleteCallback(OfflinePageModel::DeletePageResult /* result */) {
 }
 
 void FindPagesMissingArchiveFile(
-    const std::vector<std::pair<int64, base::FilePath>>& id_path_pairs,
-    std::vector<int64>* ids_of_pages_missing_archive_file) {
+    const std::vector<std::pair<int64_t, base::FilePath>>& id_path_pairs,
+    std::vector<int64_t>* ids_of_pages_missing_archive_file) {
   DCHECK(ids_of_pages_missing_archive_file);
 
   for (const auto& id_path : id_path_pairs) {
     if (!base::PathExists(id_path.second) ||
         base::DirectoryExists(id_path.second)) {
       ids_of_pages_missing_archive_file->push_back(id_path.first);
     }
   }
 }
 
@@ skipping 42 matching lines @@
 
 void OfflinePageModel::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void OfflinePageModel::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void OfflinePageModel::SavePage(const GURL& url,
-                                int64 bookmark_id,
+                                int64_t bookmark_id,
                                 scoped_ptr<OfflinePageArchiver> archiver,
                                 const SavePageCallback& callback) {
   DCHECK(is_loaded_);
 
   // Skip saving the page that is not intended to be saved, like local file
   // page.
   if (!CanSavePage(url)) {
     InformSavePageDone(callback, SavePageResult::SKIPPED);
     return;
   }
 
   DCHECK(archiver.get());
   archiver->CreateArchive(archives_dir_,
                           base::Bind(&OfflinePageModel::OnCreateArchiveDone,
                                      weak_ptr_factory_.GetWeakPtr(), url,
                                      bookmark_id, base::Time::Now(), callback));
   pending_archivers_.push_back(archiver.Pass());
 }
 
-void OfflinePageModel::MarkPageAccessed(int64 bookmark_id) {
+void OfflinePageModel::MarkPageAccessed(int64_t bookmark_id) {
   DCHECK(is_loaded_);
   auto iter = offline_pages_.find(bookmark_id);
   if (iter == offline_pages_.end())
     return;
 
   // MarkPageAccessed should not be called for a page that is being marked for
   // deletion.
   DCHECK(!iter->second.IsMarkedForDeletion());
 
   // Make a copy of the cached item and update it. The cached item should only
   // be updated upon the successful store operation.
   OfflinePageItem offline_page_item = iter->second;
   offline_page_item.last_access_time = base::Time::Now();
   offline_page_item.access_count++;
   store_->AddOrUpdateOfflinePage(
       offline_page_item,
       base::Bind(&OfflinePageModel::OnMarkPageAccesseDone,
                  weak_ptr_factory_.GetWeakPtr(), offline_page_item));
 }
 
-void OfflinePageModel::MarkPageForDeletion(int64 bookmark_id,
+void OfflinePageModel::MarkPageForDeletion(int64_t bookmark_id,
                                            const DeletePageCallback& callback) {
   DCHECK(is_loaded_);
   auto iter = offline_pages_.find(bookmark_id);
   if (iter == offline_pages_.end()) {
     InformDeletePageDone(callback, DeletePageResult::NOT_FOUND);
     return;
   }
 
   // Make a copy of the cached item and update it. The cached item should only
   // be updated upon the successful store operation.
   OfflinePageItem offline_page_item = iter->second;
   offline_page_item.MarkForDeletion();
   store_->AddOrUpdateOfflinePage(
       offline_page_item,
       base::Bind(&OfflinePageModel::OnMarkPageForDeletionDone,
                  weak_ptr_factory_.GetWeakPtr(), offline_page_item, callback));
 }
 
 void OfflinePageModel::DeletePageByBookmarkId(
-    int64 bookmark_id,
+    int64_t bookmark_id,
     const DeletePageCallback& callback) {
   DCHECK(is_loaded_);
-  std::vector<int64> bookmark_ids_to_delete;
+  std::vector<int64_t> bookmark_ids_to_delete;
   bookmark_ids_to_delete.push_back(bookmark_id);
   DeletePagesByBookmarkId(bookmark_ids_to_delete, callback);
 }
 
 void OfflinePageModel::DeletePagesByBookmarkId(
-    const std::vector<int64>& bookmark_ids,
+    const std::vector<int64_t>& bookmark_ids,
     const DeletePageCallback& callback) {
   DCHECK(is_loaded_);
 
   std::vector<base::FilePath> paths_to_delete;
   for (const auto& bookmark_id : bookmark_ids) {
     auto iter = offline_pages_.find(bookmark_id);
     if (iter != offline_pages_.end()) {
       paths_to_delete.push_back(iter->second.file_path);
     }
   }
@@ skipping 10 matching lines @@
       base::Bind(&OfflinePageModel::OnDeleteArchiveFilesDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  bookmark_ids,
                  callback,
                  base::Owned(success)));
 }
 
 void OfflinePageModel::ClearAll(const base::Closure& callback) {
   DCHECK(is_loaded_);
 
-  std::vector<int64> bookmark_ids;
+  std::vector<int64_t> bookmark_ids;
   for (const auto& id_page_pair : offline_pages_)
     bookmark_ids.push_back(id_page_pair.first);
   DeletePagesByBookmarkId(
       bookmark_ids,
       base::Bind(&OfflinePageModel::OnRemoveAllFilesDoneForClearAll,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback));
 }
 
 bool OfflinePageModel::HasOfflinePages() const {
@@ skipping 25 matching lines @@
   for (const auto& id_page_pair : offline_pages_) {
     if (!id_page_pair.second.IsMarkedForDeletion() &&
         now - id_page_pair.second.last_access_time > kPageCleanUpThreshold) {
       offline_pages.push_back(id_page_pair.second);
     }
   }
   return offline_pages;
 }
 
 const OfflinePageItem* OfflinePageModel::GetPageByBookmarkId(
-    int64 bookmark_id) const {
+    int64_t bookmark_id) const {
   const auto iter = offline_pages_.find(bookmark_id);
   return iter != offline_pages_.end() && !iter->second.IsMarkedForDeletion()
              ? &(iter->second)
              : nullptr;
 }
 
 const OfflinePageItem* OfflinePageModel::GetPageByOfflineURL(
     const GURL& offline_url) const {
   for (auto iter = offline_pages_.begin();
        iter != offline_pages_.end();
@@ skipping 12 matching lines @@
        ++iter) {
     if (iter->second.url == online_url && !iter->second.IsMarkedForDeletion())
       return &(iter->second);
   }
   return nullptr;
 }
 
 void OfflinePageModel::CheckForExternalFileDeletion() {
   DCHECK(is_loaded_);
 
-  std::vector<std::pair<int64, base::FilePath>> id_path_pairs;
+  std::vector<std::pair<int64_t, base::FilePath>> id_path_pairs;
   for (const auto& id_page_pair : offline_pages_) {
     id_path_pairs.push_back(
         std::make_pair(id_page_pair.first, id_page_pair.second.file_path));
   }
 
-  std::vector<int64>* ids_of_pages_missing_archive_file =
-      new std::vector<int64>();
+  std::vector<int64_t>* ids_of_pages_missing_archive_file =
+      new std::vector<int64_t>();
   task_runner_->PostTaskAndReply(
       FROM_HERE, base::Bind(&FindPagesMissingArchiveFile, id_path_pairs,
                             ids_of_pages_missing_archive_file),
       base::Bind(&OfflinePageModel::OnFindPagesMissingArchiveFile,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Owned(ids_of_pages_missing_archive_file)));
 }
 
 OfflinePageMetadataStore* OfflinePageModel::GetStoreForTesting() {
   return store_.get();
 }
 
 void OfflinePageModel::OnCreateArchiveDone(const GURL& requested_url,
-                                           int64 bookmark_id,
+                                           int64_t bookmark_id,
                                            const base::Time& start_time,
                                            const SavePageCallback& callback,
                                            OfflinePageArchiver* archiver,
                                            ArchiverResult archiver_result,
                                            const GURL& url,
                                            const base::FilePath& file_path,
-                                           int64 file_size) {
+                                           int64_t file_size) {
   if (requested_url != url) {
     DVLOG(1) << "Saved URL does not match requested URL.";
     // TODO(fgorski): We have created an archive for a wrong URL. It should be
     // deleted from here, once archiver has the right functionality.
     InformSavePageDone(callback, SavePageResult::ARCHIVE_CREATION_FAILED);
     DeletePendingArchiver(archiver);
     return;
   }
 
   if (archiver_result != ArchiverResult::SUCCESSFULLY_CREATED) {
@@ skipping 72 matching lines @@
 void OfflinePageModel::OnUndoOfflinePageDone(
     const OfflinePageItem& offline_page, bool success) {
   if (!success)
     return;
   offline_pages_[offline_page.bookmark_id] = offline_page;
 
   FOR_EACH_OBSERVER(Observer, observers_, OfflinePageModelChanged(this));
 }
 
 void OfflinePageModel::FinalizePageDeletion() {
-  std::vector<int64> bookmark_ids_pending_deletion;
+  std::vector<int64_t> bookmark_ids_pending_deletion;
   for (const auto& id_page_pair : offline_pages_) {
     if (!id_page_pair.second.IsMarkedForDeletion())
       continue;
     bookmark_ids_pending_deletion.push_back(id_page_pair.second.bookmark_id);
   }
   DeletePagesByBookmarkId(bookmark_ids_pending_deletion, DeletePageCallback());
 }
 
-void OfflinePageModel::UndoPageDeletion(int64 bookmark_id) {
+void OfflinePageModel::UndoPageDeletion(int64_t bookmark_id) {
   auto iter = offline_pages_.find(bookmark_id);
   if (iter == offline_pages_.end())
     return;
 
   // Make a copy of the cached item and update it. The cached item should only
   // be updated upon the successful store operation.
   OfflinePageItem offline_page_item = iter->second;
   if (!offline_page_item.IsMarkedForDeletion())
     return;
 
@@ skipping 81 matching lines @@
       static_cast<int>(SavePageResult::RESULT_COUNT));
   callback.Run(result);
 }
 
 void OfflinePageModel::DeletePendingArchiver(OfflinePageArchiver* archiver) {
   pending_archivers_.erase(std::find(
       pending_archivers_.begin(), pending_archivers_.end(), archiver));
 }
 
 void OfflinePageModel::OnDeleteArchiveFilesDone(
-    const std::vector<int64>& bookmark_ids,
+    const std::vector<int64_t>& bookmark_ids,
     const DeletePageCallback& callback,
     const bool* success) {
   DCHECK(success);
 
   if (!*success) {
     InformDeletePageDone(callback, DeletePageResult::DEVICE_FAILURE);
     return;
   }
 
   store_->RemoveOfflinePages(
       bookmark_ids,
       base::Bind(&OfflinePageModel::OnRemoveOfflinePagesDone,
                  weak_ptr_factory_.GetWeakPtr(), bookmark_ids, callback));
 }
 
 void OfflinePageModel::OnRemoveOfflinePagesDone(
-    const std::vector<int64>& bookmark_ids,
+    const std::vector<int64_t>& bookmark_ids,
     const DeletePageCallback& callback,
     bool success) {
   // Delete the offline page from the in memory cache regardless of success in
   // store.
   base::Time now = base::Time::Now();
-  int64 total_size = 0;
-  for (int64 bookmark_id : bookmark_ids) {
+  int64_t total_size = 0;
+  for (int64_t bookmark_id : bookmark_ids) {
     auto iter = offline_pages_.find(bookmark_id);
     if (iter == offline_pages_.end())
       continue;
     total_size += iter->second.file_size;
     UMA_HISTOGRAM_CUSTOM_COUNTS(
         "OfflinePages.PageLifetime",
         (now - iter->second.creation_time).InMinutes(),
         1,
         base::TimeDelta::FromDays(365).InMinutes(),
         100);
@@ skipping 39 matching lines @@
                                             DeletePageResult result) {
   UMA_HISTOGRAM_ENUMERATION(
       "OfflinePages.DeletePageResult",
       static_cast<int>(result),
       static_cast<int>(DeletePageResult::RESULT_COUNT));
   if (!callback.is_null())
     callback.Run(result);
 }
 
 void OfflinePageModel::OnFindPagesMissingArchiveFile(
-    const std::vector<int64>* ids_of_pages_missing_archive_file) {
+    const std::vector<int64_t>* ids_of_pages_missing_archive_file) {
   DCHECK(ids_of_pages_missing_archive_file);
   if (ids_of_pages_missing_archive_file->empty())
     return;
 
   DeletePageCallback done_callback(
       base::Bind(&OfflinePageModel::OnRemoveOfflinePagesMissingArchiveFileDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  *ids_of_pages_missing_archive_file));
 
   store_->RemoveOfflinePages(
       *ids_of_pages_missing_archive_file,
       base::Bind(&OfflinePageModel::OnRemoveOfflinePagesDone,
                  weak_ptr_factory_.GetWeakPtr(),
                  *ids_of_pages_missing_archive_file,
                  done_callback));
 }
 
 void OfflinePageModel::OnRemoveOfflinePagesMissingArchiveFileDone(
-    const std::vector<int64>& bookmark_ids,
+    const std::vector<int64_t>& bookmark_ids,
     OfflinePageModel::DeletePageResult /* result */) {
-  for (int64 bookmark_id : bookmark_ids) {
+  for (int64_t bookmark_id : bookmark_ids) {
     FOR_EACH_OBSERVER(Observer, observers_, OfflinePageDeleted(bookmark_id));
   }
 }
 
 void OfflinePageModel::OnRemoveAllFilesDoneForClearAll(
     const base::Closure& callback,
     DeletePageResult result) {
   store_->Reset(base::Bind(&OfflinePageModel::OnResetStoreDoneForClearAll,
                            weak_ptr_factory_.GetWeakPtr(),
                            callback));
@@ skipping 28 matching lines @@
 }
 
 void OfflinePageModel::CacheLoadedData(
     const std::vector<OfflinePageItem>& offline_pages) {
   offline_pages_.clear();
   for (const auto& offline_page : offline_pages)
     offline_pages_[offline_page.bookmark_id] = offline_page;
 }
 
 }  // namespace offline_pages