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

components/history/core/browser/typed_url_syncable_service_unittest.cc

 // Copyright (c) 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 "components/history/core/browser/typed_url_syncable_service.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "components/history/core/browser/history_backend.h"
 #include "components/history/core/browser/history_backend_client.h"
 #include "components/history/core/browser/history_database_params.h"
 #include "components/history/core/browser/history_types.h"
 #include "components/history/core/browser/in_memory_history_backend.h"
@@ skipping 40 matching lines @@
 
 bool URLsEqual(history::URLRow& lhs, history::URLRow& rhs) {
   // Only compare synced fields (ignore typed_count and visit_count as those
   // are maintained by the history subsystem).
   return (lhs.url().spec().compare(rhs.url().spec()) == 0) &&
          (lhs.title().compare(rhs.title()) == 0) &&
          (lhs.hidden() == rhs.hidden());
 }
 
 void AddNewestVisit(ui::PageTransition transition,
-                    int64 visit_time,
+                    int64_t visit_time,
                     URLRow* url,
                     VisitVector* visits) {
   base::Time time = base::Time::FromInternalValue(visit_time);
   visits->insert(visits->begin(), VisitRow(url->id(), time, 0, transition, 0));
 
   if (transition == ui::PAGE_TRANSITION_TYPED) {
     url->set_typed_count(url->typed_count() + 1);
   }
 
   url->set_last_visit(time);
   url->set_visit_count(visits->size());
 }
 
 void AddOldestVisit(ui::PageTransition transition,
-                    int64 visit_time,
+                    int64_t visit_time,
                     URLRow* url,
                     VisitVector* visits) {
   base::Time time = base::Time::FromInternalValue(visit_time);
   visits->push_back(VisitRow(url->id(), time, 0, transition, 0));
 
   if (transition == ui::PAGE_TRANSITION_TYPED) {
     url->set_typed_count(url->typed_count() + 1);
   }
 
   url->set_visit_count(visits->size());
 }
 
 // Create a new row object and the typed visit çorresponding with the time at
 // |last_visit| in the |visits| vector.
 URLRow MakeTypedUrlRow(const std::string& url,
                        const std::string& title,
                        int typed_count,
-                       int64 last_visit,
+                       int64_t last_visit,
                        bool hidden,
                        VisitVector* visits) {
   // Give each URL a unique ID, to mimic the behavior of the real database.
   GURL gurl(url);
   URLRow history_url(gurl);
   history_url.set_title(base::UTF8ToUTF16(title));
   history_url.set_typed_count(typed_count);
   history_url.set_hidden(hidden);
 
   base::Time last_visit_time = base::Time::FromInternalValue(last_visit);
   history_url.set_last_visit(last_visit_time);
 
   if (typed_count > 0) {
     // Add a typed visit for time |last_visit|.
     visits->push_back(VisitRow(history_url.id(), last_visit_time, 0,
                                ui::PAGE_TRANSITION_TYPED, 0));
   } else {
     // Add a non-typed visit for time |last_visit|.
     visits->push_back(VisitRow(history_url.id(), last_visit_time, 0,
                                ui::PAGE_TRANSITION_RELOAD, 0));
   }
 
   history_url.set_visit_count(visits->size());
   return history_url;
 }
 
 static sync_pb::TypedUrlSpecifics MakeTypedUrlSpecifics(const char* url,
                                                         const char* title,
-                                                        int64 last_visit,
+                                                        int64_t last_visit,
                                                         bool hidden) {
   sync_pb::TypedUrlSpecifics typed_url;
   typed_url.set_url(url);
   typed_url.set_title(title);
   typed_url.set_hidden(hidden);
   typed_url.add_visits(last_visit);
   typed_url.add_visit_transitions(ui::PAGE_TRANSITION_TYPED);
   return typed_url;
 }
 
@@ skipping 98 matching lines @@
                                 std::vector<VisitVector>* visit_vectors);
 
   // Fills |urls| with the set of synced urls within |typed_url_sync_service_|.
   void GetSyncedUrls(std::set<GURL>* urls) const;
 
   // Create and apply a change for url and its visits into history backend.
   VisitVector ApplyUrlAndVisitsChange(
       const std::string& url,
       const std::string& title,
       int typed_count,
-      int64 last_visit,
+      int64_t last_visit,
       bool hidden,
       syncer::SyncChange::SyncChangeType change_type);
 
   // Fills |specifics| with the sync data for |url| and |visits|.
   static void WriteToTypedUrlSpecifics(const URLRow& url,
                                        const VisitVector& visits,
                                        sync_pb::TypedUrlSpecifics* specifics);
 
   // Helper to call TypedUrlSyncableService's MergeURLs method.
   static TypedUrlSyncableService::MergeResult MergeUrls(
       const sync_pb::TypedUrlSpecifics& typed_url,
       const history::URLRow& url,
       history::VisitVector* visits,
       history::URLRow* new_url,
       std::vector<history::VisitInfo>* new_visits);
 
   // Helper to call TypedUrlSyncableService's DiffVisits method.
   static void DiffVisits(const history::VisitVector& history_visits,
                          const sync_pb::TypedUrlSpecifics& sync_specifics,
                          std::vector<history::VisitInfo>* new_visits,
                          history::VisitVector* removed_visits);
 
   // Create a new row associated with a specific visit's time.
   static history::VisitRow CreateVisit(ui::PageTransition type,
-                                       int64 timestamp);
+                                       int64_t timestamp);
 
   static const TypedUrlSyncableService::MergeResult DIFF_NONE =
       TypedUrlSyncableService::DIFF_NONE;
   static const TypedUrlSyncableService::MergeResult DIFF_UPDATE_NODE =
       TypedUrlSyncableService::DIFF_UPDATE_NODE;
   static const TypedUrlSyncableService::MergeResult DIFF_LOCAL_ROW_CHANGED =
       TypedUrlSyncableService::DIFF_LOCAL_ROW_CHANGED;
   static const TypedUrlSyncableService::MergeResult DIFF_LOCAL_VISITS_ADDED =
       TypedUrlSyncableService::DIFF_LOCAL_VISITS_ADDED;
 
@@ skipping 60 matching lines @@
 }
 
 void TypedUrlSyncableServiceTest::GetSyncedUrls(std::set<GURL>* urls) const {
   return typed_url_sync_service_->GetSyncedUrls(urls);
 }
 
 VisitVector TypedUrlSyncableServiceTest::ApplyUrlAndVisitsChange(
     const std::string& url,
     const std::string& title,
     int typed_count,
-    int64 last_visit,
+    int64_t last_visit,
     bool hidden,
     syncer::SyncChange::SyncChangeType change_type) {
   VisitVector visits;
   URLRow row =
       MakeTypedUrlRow(url, title, typed_count, last_visit, hidden, &visits);
   syncer::SyncChangeList change_list;
   sync_pb::EntitySpecifics entity_specifics;
   sync_pb::TypedUrlSpecifics* typed_url_specifics =
       entity_specifics.mutable_typed_url();
   WriteToTypedUrlSpecifics(row, visits, typed_url_specifics);
@@ skipping 31 matching lines @@
     const sync_pb::TypedUrlSpecifics& sync_specifics,
     std::vector<history::VisitInfo>* new_visits,
     history::VisitVector* removed_visits) {
   TypedUrlSyncableService::DiffVisits(history_visits, sync_specifics,
                                       new_visits, removed_visits);
 }
 
 // Static.
 history::VisitRow TypedUrlSyncableServiceTest::CreateVisit(
     ui::PageTransition type,
-    int64 timestamp) {
+    int64_t timestamp) {
   return history::VisitRow(0, base::Time::FromInternalValue(timestamp), 0, type,
                            0);
 }
 
 // Create a local typed URL with one TYPED visit after sync has started. Check
 // that sync is sent an ADD change for the new URL.
 TEST_F(TypedUrlSyncableServiceTest, AddLocalTypedUrl) {
   // Create a local typed URL (simulate a typed visit) that is not already
   // in sync. Check that sync is sent an ADD change for the existing URL.
   URLRows url_rows;
@@ skipping 722 matching lines @@
   url_id = fake_history_backend_->GetIdByUrl(GURL(kURL));
   ASSERT_EQ(0, url_id);
 }
 
 // Create two set of visits for history DB and sync DB, two same set of visits
 // are same. Check DiffVisits will return empty set of diff visits.
 TEST_F(TypedUrlSyncableServiceTest, DiffVisitsSame) {
   history::VisitVector old_visits;
   sync_pb::TypedUrlSpecifics new_url;
 
-  const int64 visits[] = {1024, 2065, 65534, 1237684};
+  const int64_t visits[] = {1024, 2065, 65534, 1237684};
 
-  for (int64 visit : visits) {
+  for (int64_t visit : visits) {
     old_visits.push_back(history::VisitRow(0,
                                            base::Time::FromInternalValue(visit),
                                            0, ui::PAGE_TRANSITION_TYPED, 0));
     new_url.add_visits(visit);
     new_url.add_visit_transitions(ui::PAGE_TRANSITION_TYPED);
   }
 
   std::vector<history::VisitInfo> new_visits;
   history::VisitVector removed_visits;
 
   DiffVisits(old_visits, new_url, &new_visits, &removed_visits);
   EXPECT_TRUE(new_visits.empty());
   EXPECT_TRUE(removed_visits.empty());
 }
 
 // Create two set of visits for history DB and sync DB. Check DiffVisits will
 // return correct set of diff visits.
 TEST_F(TypedUrlSyncableServiceTest, DiffVisitsRemove) {
   history::VisitVector old_visits;
   sync_pb::TypedUrlSpecifics new_url;
 
-  const int64 visits_left[] = {1,    2,     1024,    1500,   2065,
-                               6000, 65534, 1237684, 2237684};
-  const int64 visits_right[] = {1024, 2065, 65534, 1237684};
+  const int64_t visits_left[] = {1,    2,     1024,    1500,   2065,
+                                 6000, 65534, 1237684, 2237684};
+  const int64_t visits_right[] = {1024, 2065, 65534, 1237684};
 
   // DiffVisits will not remove the first visit, because we never delete visits
   // from the start of the array (since those visits can get truncated by the
   // size-limiting code).
-  const int64 visits_removed[] = {1500, 6000, 2237684};
+  const int64_t visits_removed[] = {1500, 6000, 2237684};
 
-  for (int64 visit : visits_left) {
+  for (int64_t visit : visits_left) {
     old_visits.push_back(history::VisitRow(0,
                                            base::Time::FromInternalValue(visit),
                                            0, ui::PAGE_TRANSITION_TYPED, 0));
   }
 
-  for (int64 visit : visits_right) {
+  for (int64_t visit : visits_right) {
     new_url.add_visits(visit);
     new_url.add_visit_transitions(ui::PAGE_TRANSITION_TYPED);
   }
 
   std::vector<history::VisitInfo> new_visits;
   history::VisitVector removed_visits;
 
   DiffVisits(old_visits, new_url, &new_visits, &removed_visits);
   EXPECT_TRUE(new_visits.empty());
   ASSERT_EQ(removed_visits.size(), arraysize(visits_removed));
   for (size_t i = 0; i < arraysize(visits_removed); ++i) {
     EXPECT_EQ(removed_visits[i].visit_time.ToInternalValue(),
               visits_removed[i]);
   }
 }
 
 // Create two set of visits for history DB and sync DB. Check DiffVisits will
 // return correct set of diff visits.
 TEST_F(TypedUrlSyncableServiceTest, DiffVisitsAdd) {
   history::VisitVector old_visits;
   sync_pb::TypedUrlSpecifics new_url;
 
-  const int64 visits_left[] = {1024, 2065, 65534, 1237684};
-  const int64 visits_right[] = {1,    1024,  1500,    2065,
-                                6000, 65534, 1237684, 2237684};
+  const int64_t visits_left[] = {1024, 2065, 65534, 1237684};
+  const int64_t visits_right[] = {1,    1024,  1500,    2065,
+                                  6000, 65534, 1237684, 2237684};
 
-  const int64 visits_added[] = {1, 1500, 6000, 2237684};
+  const int64_t visits_added[] = {1, 1500, 6000, 2237684};
 
-  for (int64 visit : visits_left) {
+  for (int64_t visit : visits_left) {
     old_visits.push_back(history::VisitRow(0,
                                            base::Time::FromInternalValue(visit),
                                            0, ui::PAGE_TRANSITION_TYPED, 0));
   }
 
-  for (int64 visit : visits_right) {
+  for (int64_t visit : visits_right) {
     new_url.add_visits(visit);
     new_url.add_visit_transitions(ui::PAGE_TRANSITION_TYPED);
   }
 
   std::vector<history::VisitInfo> new_visits;
   history::VisitVector removed_visits;
 
   DiffVisits(old_visits, new_url, &new_visits, &removed_visits);
   EXPECT_TRUE(removed_visits.empty());
   ASSERT_TRUE(new_visits.size() == arraysize(visits_added));
@@ skipping 21 matching lines @@
   EXPECT_EQ(3, typed_url.visits(1));
   EXPECT_EQ(ui::PAGE_TRANSITION_TYPED,
             ui::PageTransitionFromInt(typed_url.visit_transitions(0)));
   EXPECT_EQ(ui::PAGE_TRANSITION_LINK,
             ui::PageTransitionFromInt(typed_url.visit_transitions(1)));
 }
 
 // Create 101 visits, check WriteToTypedUrlSpecifics will only keep 100 visits.
 TEST_F(TypedUrlSyncableServiceTest, TooManyVisits) {
   history::VisitVector visits;
-  int64 timestamp = 1000;
+  int64_t timestamp = 1000;
   visits.push_back(CreateVisit(ui::PAGE_TRANSITION_TYPED, timestamp++));
   for (int i = 0; i < 100; ++i) {
     visits.push_back(CreateVisit(ui::PAGE_TRANSITION_LINK, timestamp++));
   }
   history::URLRow url(
       MakeTypedUrlRow(kURL, kTitle, 0, timestamp++, false, &visits));
   sync_pb::TypedUrlSpecifics typed_url;
   WriteToTypedUrlSpecifics(url, visits, &typed_url);
   // # visits should be capped at 100.
   EXPECT_EQ(100, typed_url.visits_size());
   EXPECT_EQ(typed_url.visit_transitions_size(), typed_url.visits_size());
   EXPECT_EQ(1000, typed_url.visits(0));
   // Visit with timestamp of 1001 should be omitted since we should have
   // skipped that visit to stay under the cap.
   EXPECT_EQ(1002, typed_url.visits(1));
   EXPECT_EQ(ui::PAGE_TRANSITION_TYPED,
             ui::PageTransitionFromInt(typed_url.visit_transitions(0)));
   EXPECT_EQ(ui::PAGE_TRANSITION_LINK,
             ui::PageTransitionFromInt(typed_url.visit_transitions(1)));
 }
 
 // Create 306 visits, check WriteToTypedUrlSpecifics will only keep 100 typed
 // visits.
 TEST_F(TypedUrlSyncableServiceTest, TooManyTypedVisits) {
   history::VisitVector visits;
-  int64 timestamp = 1000;
+  int64_t timestamp = 1000;
   for (int i = 0; i < 102; ++i) {
     visits.push_back(CreateVisit(ui::PAGE_TRANSITION_TYPED, timestamp++));
     visits.push_back(CreateVisit(ui::PAGE_TRANSITION_LINK, timestamp++));
     visits.push_back(CreateVisit(ui::PAGE_TRANSITION_RELOAD, timestamp++));
   }
   history::URLRow url(
       MakeTypedUrlRow(kURL, kTitle, 0, timestamp++, false, &visits));
   sync_pb::TypedUrlSpecifics typed_url;
   WriteToTypedUrlSpecifics(url, visits, &typed_url);
   // # visits should be capped at 100.
@@ skipping 139 matching lines @@
   // We should not sync the visit with timestamp #1 since it is earlier than
   // any other visit for this URL in the history DB. But we should sync visit
   // #4.
   EXPECT_EQ(3U, history_visits.size());
   EXPECT_EQ(2U, history_visits[0].visit_time.ToInternalValue());
   EXPECT_EQ(3U, history_visits[1].visit_time.ToInternalValue());
   EXPECT_EQ(4U, history_visits[2].visit_time.ToInternalValue());
 }
 
 }  // namespace history