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

components/offline_pages/offline_page_model_unittest.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 <stdint.h>
+
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/test_mock_time_task_runner.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 11 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 using SavePageResult = offline_pages::OfflinePageModel::SavePageResult;
 using DeletePageResult = offline_pages::OfflinePageModel::DeletePageResult;
 
 namespace offline_pages {
 
 namespace {
 const GURL kTestUrl("http://example.com");
-const int64 kTestPageBookmarkId1 = 1234LL;
+const int64_t kTestPageBookmarkId1 = 1234LL;
 const GURL kTestUrl2("http://other.page.com");
 const GURL kTestUrl3("http://test.xyz");
 const GURL kFileUrl("file:///foo");
-const int64 kTestPageBookmarkId2 = 5678LL;
-const int64 kTestPageBookmarkId3 = 42LL;
-const int64 kTestFileSize = 876543LL;
+const int64_t kTestPageBookmarkId2 = 5678LL;
+const int64_t kTestPageBookmarkId3 = 42LL;
+const int64_t kTestFileSize = 876543LL;
 
 }  // namespace
 
 class OfflinePageModelTest
     : public testing::Test,
       public OfflinePageModel::Observer,
       public OfflinePageTestArchiver::Observer,
       public base::SupportsWeakPtr<OfflinePageModelTest> {
  public:
   OfflinePageModelTest();
   ~OfflinePageModelTest() override;
 
   void SetUp() override;
   void TearDown() override;
 
   // OfflinePageModel::Observer implementation.
   void OfflinePageModelLoaded(OfflinePageModel* model) override;
   void OfflinePageModelChanged(OfflinePageModel* model) override;
-  void OfflinePageDeleted(int64 bookmark_id) override;
+  void OfflinePageDeleted(int64_t bookmark_id) override;
 
   // OfflinePageTestArchiver::Observer implementation.
   void SetLastPathCreatedByArchiver(const base::FilePath& file_path) override;
 
   // OfflinePageModel callbacks.
   void OnSavePageDone(SavePageResult result);
   void OnDeletePageDone(DeletePageResult result);
   void OnClearAllDone();
 
   // OfflinePageMetadataStore callbacks.
@@ skipping 11 matching lines @@
   // Runs until all of the tasks that are not delayed are gone from the task
   // queue.
   void PumpLoop();
   // Fast-forwards virtual time by |delta|, causing tasks with a remaining
   // delay less than or equal to |delta| to be executed.
   void FastForwardBy(base::TimeDelta delta);
   void ResetResults();
 
   OfflinePageTestStore* GetStore();
 
-  void SavePage(const GURL& url, int64 bookmark_id);
-  void SavePageWithArchiverResult(
-      const GURL& url,
-      int64 bookmark_id,
-      OfflinePageArchiver::ArchiverResult result);
+  void SavePage(const GURL& url, int64_t bookmark_id);
+  void SavePageWithArchiverResult(const GURL& url,
+                                  int64_t bookmark_id,
+                                  OfflinePageArchiver::ArchiverResult result);
 
   OfflinePageModel* model() { return model_.get(); }
 
   SavePageResult last_save_result() const {
     return last_save_result_;
   }
 
   DeletePageResult last_delete_result() const {
     return last_delete_result_;
   }
 
-  int64 last_deleted_bookmark_id() const {
-    return last_deleted_bookmark_id_;
-  }
+  int64_t last_deleted_bookmark_id() const { return last_deleted_bookmark_id_; }
 
   const base::FilePath& last_archiver_path() { return last_archiver_path_; }
 
  private:
   scoped_refptr<base::TestMockTimeTaskRunner> task_runner_;
   base::ThreadTaskRunnerHandle task_runner_handle_;
   base::ScopedTempDir temp_dir_;
 
   scoped_ptr<OfflinePageModel> model_;
   SavePageResult last_save_result_;
   DeletePageResult last_delete_result_;
   base::FilePath last_archiver_path_;
-  int64 last_deleted_bookmark_id_;
+  int64_t last_deleted_bookmark_id_;
 };
 
 OfflinePageModelTest::OfflinePageModelTest()
     : task_runner_(new base::TestMockTimeTaskRunner),
       task_runner_handle_(task_runner_),
       last_save_result_(SavePageResult::CANCELLED),
       last_delete_result_(DeletePageResult::CANCELLED),
       last_deleted_bookmark_id_(-1) {
 }
 
@@ skipping 14 matching lines @@
 }
 
 void OfflinePageModelTest::OfflinePageModelLoaded(OfflinePageModel* model) {
   ASSERT_EQ(model_.get(), model);
 }
 
 void OfflinePageModelTest::OfflinePageModelChanged(OfflinePageModel* model) {
   ASSERT_EQ(model_.get(), model);
 }
 
-void OfflinePageModelTest::OfflinePageDeleted(int64 bookmark_id) {
+void OfflinePageModelTest::OfflinePageDeleted(int64_t bookmark_id) {
   last_deleted_bookmark_id_ = bookmark_id;
 }
 
 void OfflinePageModelTest::SetLastPathCreatedByArchiver(
     const base::FilePath& file_path) {
   last_archiver_path_ = file_path;
 }
 
 void OfflinePageModelTest::OnSavePageDone(
     OfflinePageModel::SavePageResult result) {
@@ skipping 50 matching lines @@
 void OfflinePageModelTest::ResetResults() {
   last_save_result_ = SavePageResult::CANCELLED;
   last_delete_result_ = DeletePageResult::CANCELLED;
   last_archiver_path_.clear();
 }
 
 OfflinePageTestStore* OfflinePageModelTest::GetStore() {
   return static_cast<OfflinePageTestStore*>(model()->GetStoreForTesting());
 }
 
-void OfflinePageModelTest::SavePage(const GURL& url, int64 bookmark_id) {
+void OfflinePageModelTest::SavePage(const GURL& url, int64_t bookmark_id) {
   SavePageWithArchiverResult(
       url,
       bookmark_id,
       OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED);
 }
 
 void OfflinePageModelTest::SavePageWithArchiverResult(
     const GURL& url,
-    int64 bookmark_id,
+    int64_t bookmark_id,
     OfflinePageArchiver::ArchiverResult result) {
   scoped_ptr<OfflinePageTestArchiver> archiver(
       BuildArchiver(url, result).Pass());
   model()->SavePage(
       url, bookmark_id, archiver.Pass(),
       base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
   PumpLoop();
 }
 
 TEST_F(OfflinePageModelTest, SavePageSuccessful) {
@@ skipping 353 matching lines @@
                     OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED)
           .Pass());
   model()->SavePage(
       kTestUrl3, kTestPageBookmarkId3, archiver3.Pass(),
       base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
   PumpLoop();
 
   EXPECT_EQ(3u, store->GetAllPages().size());
 
   // Delete multiple pages.
-  std::vector<int64> ids_to_delete;
+  std::vector<int64_t> ids_to_delete;
   ids_to_delete.push_back(kTestPageBookmarkId2);
   ids_to_delete.push_back(kTestPageBookmarkId1);
   ids_to_delete.push_back(23434LL);  // Non-existent ID.
   model()->DeletePagesByBookmarkId(
       ids_to_delete, base::Bind(&OfflinePageModelTest::OnDeletePageDone,
                                 AsWeakPtr()));
   PumpLoop();
 
   // Success is expected if at least one page is deleted successfully.
   EXPECT_EQ(DeletePageResult::SUCCESS, last_delete_result());
@@ skipping 300 matching lines @@
   PumpLoop();
   EXPECT_EQ(0UL, model()->GetAllPages().size());
 
   // The offline copy should be restored upon the bookmark restore.
   UndoBookmarkRemoval();
   PumpLoop();
   EXPECT_EQ(1UL, model()->GetAllPages().size());
 }
 
 }  // namespace offline_pages