[Sync] Merge //components/browser_sync into one directory.

components/browser_sync/profile_sync_service_typed_url_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
-#include "components/browser_sync/browser/abstract_profile_sync_service_test.h"
-#include "components/browser_sync/browser/test_profile_sync_service.h"
+#include "components/browser_sync/abstract_profile_sync_service_test.h"
+#include "components/browser_sync/test_profile_sync_service.h"
 #include "components/history/core/browser/history_backend.h"
 #include "components/history/core/browser/history_backend_client.h"
 #include "components/history/core/browser/history_backend_notifier.h"
 #include "components/history/core/browser/history_db_task.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/history/core/browser/typed_url_data_type_controller.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "components/sync/api/data_type_error_handler_mock.h"
 #include "components/sync/core/read_node.h"
 #include "components/sync/core/read_transaction.h"
@@ skipping 26 matching lines @@
 }
 
 class HistoryBackendMock : public HistoryBackend {
  public:
   HistoryBackendMock()
       : HistoryBackend(nullptr, nullptr, base::ThreadTaskRunnerHandle::Get()) {}
   bool IsExpiredVisitTime(const base::Time& time) override {
     return time.ToInternalValue() == EXPIRED_VISIT;
   }
   MOCK_METHOD1(GetAllTypedURLs, bool(history::URLRows* entries));
-  MOCK_METHOD3(GetMostRecentVisitsForURL, bool(history::URLID id,
-                                               int max_visits,
-                                               history::VisitVector* visits));
+  MOCK_METHOD3(GetMostRecentVisitsForURL,
+               bool(history::URLID id,
+                    int max_visits,
+                    history::VisitVector* visits));
   MOCK_METHOD2(UpdateURL, bool(history::URLID id, const history::URLRow& url));
-  MOCK_METHOD3(AddVisits, bool(const GURL& url,
-                               const std::vector<history::VisitInfo>& visits,
-                               history::VisitSource visit_source));
+  MOCK_METHOD3(AddVisits,
+               bool(const GURL& url,
+                    const std::vector<history::VisitInfo>& visits,
+                    history::VisitSource visit_source));
   MOCK_METHOD2(GetURL, bool(const GURL& url_id, history::URLRow* url_row));
-  MOCK_METHOD2(SetPageTitle, void(const GURL& url,
-                                  const base::string16& title));
+  MOCK_METHOD2(SetPageTitle,
+               void(const GURL& url, const base::string16& title));
   MOCK_METHOD1(DeleteURL, void(const GURL& url));
 
  private:
   friend class ProfileSyncServiceTypedUrlTest;
 
   virtual ~HistoryBackendMock() {}
 };
 
 class HistoryServiceMock : public history::HistoryService {
  public:
   HistoryServiceMock() : history::HistoryService(), backend_(nullptr) {}
 
   base::CancelableTaskTracker::TaskId ScheduleDBTask(
       std::unique_ptr<history::HistoryDBTask> task,
       base::CancelableTaskTracker* tracker) override {
     // Explicitly copy out the raw pointer -- compilers might decide to
     // evaluate task.release() before the arguments for the first Bind().
     history::HistoryDBTask* task_raw = task.get();
     task_runner_->PostTaskAndReply(
-        FROM_HERE,
-        base::Bind(&HistoryServiceMock::RunTaskOnDBThread,
-                   base::Unretained(this), task_raw),
+        FROM_HERE, base::Bind(&HistoryServiceMock::RunTaskOnDBThread,
+                              base::Unretained(this), task_raw),
         base::Bind(&base::DeletePointer<history::HistoryDBTask>,
                    task.release()));
     return base::CancelableTaskTracker::kBadTaskId;  // unused
   }
 
   ~HistoryServiceMock() override {}
 
   void set_task_runner(
       scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
     DCHECK(task_runner.get());
@@ skipping 190 matching lines @@
         FROM_HERE, task,
         base::Bind(&base::MessageLoop::QuitNow,
                    base::Unretained(base::MessageLoop::current())));
     base::RunLoop().Run();
   }
 
   void SendNotificationURLVisited(ui::PageTransition transition,
                                   const history::URLRow& row) {
     base::Time visit_time;
     history::RedirectList redirects;
-    SendNotification(
-        base::Bind(&HistoryBackendNotifier::NotifyURLVisited,
-                   base::Unretained(history_backend_.get()),
-                   transition,
-                   row,
-                   redirects,
-                   visit_time));
+    SendNotification(base::Bind(&HistoryBackendNotifier::NotifyURLVisited,
+                                base::Unretained(history_backend_.get()),
+                                transition, row, redirects, visit_time));
   }
 
   void SendNotificationURLsModified(const history::URLRows& rows) {
     SendNotification(base::Bind(&HistoryBackendNotifier::NotifyURLsModified,
                                 base::Unretained(history_backend_.get()),
                                 rows));
   }
 
   void SendNotificationURLsDeleted(bool all_history,
                                    bool expired,
@@ skipping 21 matching lines @@
                                            int typed_count,
                                            int64_t last_visit,
                                            bool hidden,
                                            history::VisitVector* visits) {
     // Give each URL a unique ID, to mimic the behavior of the real database.
     static int unique_url_id = 0;
     GURL gurl(url);
     history::URLRow history_url(gurl, ++unique_url_id);
     history_url.set_title(base::UTF8ToUTF16(title));
     history_url.set_typed_count(typed_count);
-    history_url.set_last_visit(
-        base::Time::FromInternalValue(last_visit));
+    history_url.set_last_visit(base::Time::FromInternalValue(last_visit));
     history_url.set_hidden(hidden);
-    visits->push_back(history::VisitRow(
-        history_url.id(), history_url.last_visit(), 0,
-        ui::PAGE_TRANSITION_TYPED, 0));
+    visits->push_back(history::VisitRow(history_url.id(),
+                                        history_url.last_visit(), 0,
+                                        ui::PAGE_TRANSITION_TYPED, 0));
     history_url.set_visit_count(visits->size());
     return history_url;
   }
 
   base::WeakPtr<syncer::SyncableService> GetSyncableServiceForType(
       syncer::ModelType type) {
     DCHECK_EQ(syncer::TYPED_URLS, type);
     return syncable_service_->AsWeakPtr();
   }
 
   HistoryBackendMock& history_backend() { return *history_backend_.get(); }
 
  private:
   scoped_refptr<HistoryBackendMock> history_backend_;
   std::unique_ptr<HistoryServiceMock> history_service_;
   syncer::DataTypeErrorHandlerMock error_handler_;
   std::unique_ptr<TestTypedUrlSyncableService> syncable_service_;
   std::unique_ptr<sync_driver::FakeSyncClient> sync_client_;
 
   DISALLOW_COPY_AND_ASSIGN(ProfileSyncServiceTypedUrlTest);
 };
 
 void AddTypedUrlEntries(ProfileSyncServiceTypedUrlTest* test,
                         const history::URLRows& entries) {
   test->CreateRoot(syncer::TYPED_URLS);
   for (size_t i = 0; i < entries.size(); ++i) {
     history::VisitVector visits;
-    visits.push_back(history::VisitRow(
-        entries[i].id(), entries[i].last_visit(), 0,
-        ui::PageTransitionFromInt(0), 0));
+    visits.push_back(history::VisitRow(entries[i].id(), entries[i].last_visit(),
+                                       0, ui::PageTransitionFromInt(0), 0));
     test->AddTypedUrlSyncNode(entries[i], visits);
   }
 }
 
 }  // namespace
 
 TEST_F(ProfileSyncServiceTypedUrlTest, EmptyNativeEmptySync) {
   EXPECT_CALL((history_backend()), GetAllTypedURLs(_)).WillOnce(Return(true));
   SetIdleChangeProcessorExpectations();
   CreateRootHelper create_root(this, syncer::TYPED_URLS);
   TypedUrlSyncableService* syncable_service =
       StartSyncService(create_root.callback());
   history::URLRows sync_entries;
   GetTypedUrlsFromSyncDB(&sync_entries);
   EXPECT_EQ(0U, sync_entries.size());
   ASSERT_EQ(0, syncable_service->GetErrorPercentage());
 }
 
 TEST_F(ProfileSyncServiceTypedUrlTest, HasNativeEmptySync) {
   history::URLRows entries;
   history::VisitVector visits;
-  entries.push_back(MakeTypedUrlEntry("http://foo.com", "bar",
-                                      2, 15, false, &visits));
+  entries.push_back(
+      MakeTypedUrlEntry("http://foo.com", "bar", 2, 15, false, &visits));
 
   EXPECT_CALL((history_backend()), GetAllTypedURLs(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(entries), Return(true)));
   EXPECT_CALL((history_backend()), GetMostRecentVisitsForURL(_, _, _))
       .WillRepeatedly(DoAll(SetArgumentPointee<2>(visits), Return(true)));
   SetIdleChangeProcessorExpectations();
   CreateRootHelper create_root(this, syncer::TYPED_URLS);
   TypedUrlSyncableService* syncable_service =
       StartSyncService(create_root.callback());
   history::URLRows sync_entries;
   GetTypedUrlsFromSyncDB(&sync_entries);
   ASSERT_EQ(1U, sync_entries.size());
   EXPECT_TRUE(URLsEqual(entries[0], sync_entries[0]));
   ASSERT_EQ(0, syncable_service->GetErrorPercentage());
 }
 
 TEST_F(ProfileSyncServiceTypedUrlTest, HasNativeErrorReadingVisits) {
   history::URLRows entries;
   history::VisitVector visits;
-  history::URLRow native_entry1(MakeTypedUrlEntry("http://foo.com", "bar",
-                                                  2, 15, false, &visits));
-  history::URLRow native_entry2(MakeTypedUrlEntry("http://foo2.com", "bar",
-                                                  3, 15, false, &visits));
+  history::URLRow native_entry1(
+      MakeTypedUrlEntry("http://foo.com", "bar", 2, 15, false, &visits));
+  history::URLRow native_entry2(
+      MakeTypedUrlEntry("http://foo2.com", "bar", 3, 15, false, &visits));
   entries.push_back(native_entry1);
   entries.push_back(native_entry2);
   EXPECT_CALL((history_backend()), GetAllTypedURLs(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(entries), Return(true)));
   // Return an error from GetMostRecentVisitsForURL() for the second URL.
   EXPECT_CALL((history_backend()),
               GetMostRecentVisitsForURL(native_entry1.id(), _, _))
       .WillRepeatedly(Return(true));
   EXPECT_CALL((history_backend()),
               GetMostRecentVisitsForURL(native_entry2.id(), _, _))
       .WillRepeatedly(Return(false));
   SetIdleChangeProcessorExpectations();
   CreateRootHelper create_root(this, syncer::TYPED_URLS);
   StartSyncService(create_root.callback());
   history::URLRows sync_entries;
   GetTypedUrlsFromSyncDB(&sync_entries);
   ASSERT_EQ(1U, sync_entries.size());
   EXPECT_TRUE(URLsEqual(native_entry1, sync_entries[0]));
 }
 
 TEST_F(ProfileSyncServiceTypedUrlTest, HasNativeWithBlankEmptySync) {
   std::vector<history::URLRow> entries;
   history::VisitVector visits;
   // Add an empty URL.
-  entries.push_back(MakeTypedUrlEntry("", "bar",
-                                      2, 15, false, &visits));
-  entries.push_back(MakeTypedUrlEntry("http://foo.com", "bar",
-                                      2, 15, false, &visits));
+  entries.push_back(MakeTypedUrlEntry("", "bar", 2, 15, false, &visits));
+  entries.push_back(
+      MakeTypedUrlEntry("http://foo.com", "bar", 2, 15, false, &visits));
   EXPECT_CALL((history_backend()), GetAllTypedURLs(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(entries), Return(true)));
   EXPECT_CALL((history_backend()), GetMostRecentVisitsForURL(_, _, _))
       .WillRepeatedly(DoAll(SetArgumentPointee<2>(visits), Return(true)));
   SetIdleChangeProcessorExpectations();
   CreateRootHelper create_root(this, syncer::TYPED_URLS);
   StartSyncService(create_root.callback());
   std::vector<history::URLRow> sync_entries;
   GetTypedUrlsFromSyncDB(&sync_entries);
   // The empty URL should be ignored.
   ASSERT_EQ(1U, sync_entries.size());
   EXPECT_TRUE(URLsEqual(entries[1], sync_entries[0]));
 }
 
 TEST_F(ProfileSyncServiceTypedUrlTest, HasNativeHasSyncNoMerge) {
   history::VisitVector native_visits;
   history::VisitVector sync_visits;
   history::URLRow native_entry(MakeTypedUrlEntry("http://native.com", "entry",
                                                  2, 15, false, &native_visits));
-  history::URLRow sync_entry(MakeTypedUrlEntry("http://sync.com", "entry",
-                                               3, 16, false, &sync_visits));
+  history::URLRow sync_entry(MakeTypedUrlEntry("http://sync.com", "entry", 3,
+                                               16, false, &sync_visits));
 
   history::URLRows native_entries;
   native_entries.push_back(native_entry);
   EXPECT_CALL((history_backend()), GetAllTypedURLs(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(native_entries), Return(true)));
   EXPECT_CALL((history_backend()), GetMostRecentVisitsForURL(_, _, _))
       .WillRepeatedly(
           DoAll(SetArgumentPointee<2>(native_visits), Return(true)));
   EXPECT_CALL((history_backend()), AddVisits(_, _, history::SOURCE_SYNCED))
       .WillRepeatedly(Return(true));
@@ skipping 14 matching lines @@
 
   EXPECT_TRUE(new_sync_entries.size() == expected.size());
   for (history::URLRows::iterator entry = new_sync_entries.begin();
        entry != new_sync_entries.end(); ++entry) {
     EXPECT_TRUE(URLsEqual(expected[entry->url().spec()], *entry));
   }
 }
 
 TEST_F(ProfileSyncServiceTypedUrlTest, EmptyNativeExpiredSync) {
   history::VisitVector sync_visits;
-  history::URLRow sync_entry(MakeTypedUrlEntry("http://sync.com", "entry",
-                                               3, EXPIRED_VISIT, false,
-                                               &sync_visits));
+  history::URLRow sync_entry(MakeTypedUrlEntry(
+      "http://sync.com", "entry", 3, EXPIRED_VISIT, false, &sync_visits));
   history::URLRows sync_entries;
   sync_entries.push_back(sync_entry);
 
   // Since all our URLs are expired, no backend calls to add new URLs will be
   // made.
   EXPECT_CALL((history_backend()), GetAllTypedURLs(_)).WillOnce(Return(true));
   SetIdleChangeProcessorExpectations();
 
   StartSyncService(base::Bind(&AddTypedUrlEntries, this, sync_entries));
 }
 
 TEST_F(ProfileSyncServiceTypedUrlTest, HasNativeHasSyncMerge) {
   history::VisitVector native_visits;
   history::URLRow native_entry(MakeTypedUrlEntry("http://native.com", "entry",
                                                  2, 15, false, &native_visits));
   history::VisitVector sync_visits;
-  history::URLRow sync_entry(MakeTypedUrlEntry("http://native.com", "name",
-                                               1, 17, false, &sync_visits));
+  history::URLRow sync_entry(MakeTypedUrlEntry("http://native.com", "name", 1,
+                                               17, false, &sync_visits));
   history::VisitVector merged_visits;
-  merged_visits.push_back(history::VisitRow(
-      sync_entry.id(), base::Time::FromInternalValue(15), 0,
-      ui::PageTransitionFromInt(0), 0));
+  merged_visits.push_back(
+      history::VisitRow(sync_entry.id(), base::Time::FromInternalValue(15), 0,
+                        ui::PageTransitionFromInt(0), 0));
 
-  history::URLRow merged_entry(MakeTypedUrlEntry("http://native.com", "name",
-                                                 2, 17, false, &merged_visits));
+  history::URLRow merged_entry(MakeTypedUrlEntry("http://native.com", "name", 2,
+                                                 17, false, &merged_visits));
 
   history::URLRows native_entries;
   native_entries.push_back(native_entry);
   EXPECT_CALL((history_backend()), GetAllTypedURLs(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(native_entries), Return(true)));
   EXPECT_CALL((history_backend()), GetMostRecentVisitsForURL(_, _, _))
       .WillRepeatedly(
           DoAll(SetArgumentPointee<2>(native_visits), Return(true)));
   EXPECT_CALL((history_backend()), AddVisits(_, _, history::SOURCE_SYNCED))
       .WillRepeatedly(Return(true));
@@ skipping 10 matching lines @@
   GetTypedUrlsFromSyncDB(&new_sync_entries);
   ASSERT_EQ(1U, new_sync_entries.size());
   EXPECT_TRUE(URLsEqual(merged_entry, new_sync_entries[0]));
 }
 
 TEST_F(ProfileSyncServiceTypedUrlTest, HasNativeWithErrorHasSyncMerge) {
   history::VisitVector native_visits;
   history::URLRow native_entry(MakeTypedUrlEntry("http://native.com", "native",
                                                  2, 15, false, &native_visits));
   history::VisitVector sync_visits;
-  history::URLRow sync_entry(MakeTypedUrlEntry("http://native.com", "sync",
-                                               1, 17, false, &sync_visits));
+  history::URLRow sync_entry(MakeTypedUrlEntry("http://native.com", "sync", 1,
+                                               17, false, &sync_visits));
 
   history::URLRows native_entries;
   native_entries.push_back(native_entry);
   EXPECT_CALL((history_backend()), GetAllTypedURLs(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(native_entries), Return(true)));
   // Return an error getting the visits for the native URL.
   EXPECT_CALL((history_backend()), GetMostRecentVisitsForURL(_, _, _))
       .WillRepeatedly(Return(false));
   EXPECT_CALL((history_backend()), GetURL(_, _))
       .WillRepeatedly(DoAll(SetArgumentPointee<1>(native_entry), Return(true)));
   EXPECT_CALL((history_backend()), AddVisits(_, _, history::SOURCE_SYNCED))
       .WillRepeatedly(Return(true));
 
   history::URLRows sync_entries;
   sync_entries.push_back(sync_entry);
 
   EXPECT_CALL((history_backend()), UpdateURL(_, _))
       .WillRepeatedly(Return(true));
   EXPECT_CALL((history_backend()), SetPageTitle(_, _)).WillRepeatedly(Return());
   StartSyncService(base::Bind(&AddTypedUrlEntries, this, sync_entries));
 
   history::URLRows new_sync_entries;
   GetTypedUrlsFromSyncDB(&new_sync_entries);
   ASSERT_EQ(1U, new_sync_entries.size());
   EXPECT_TRUE(URLsEqual(sync_entry, new_sync_entries[0]));
 }
 
 TEST_F(ProfileSyncServiceTypedUrlTest, ProcessUserChangeAdd) {
   history::VisitVector added_visits;
-  history::URLRow added_entry(MakeTypedUrlEntry("http://added.com", "entry",
-                                                2, 15, false, &added_visits));
+  history::URLRow added_entry(MakeTypedUrlEntry("http://added.com", "entry", 2,
+                                                15, false, &added_visits));
 
   EXPECT_CALL((history_backend()), GetAllTypedURLs(_)).WillOnce(Return(true));
   EXPECT_CALL((history_backend()), GetMostRecentVisitsForURL(_, _, _))
       .WillOnce(DoAll(SetArgumentPointee<2>(added_visits), Return(true)));
 
   SetIdleChangeProcessorExpectations();
   CreateRootHelper create_root(this, syncer::TYPED_URLS);
   StartSyncService(create_root.callback());
 
   history::URLRows changed_urls;
   changed_urls.push_back(added_entry);
   SendNotificationURLsModified(changed_urls);
 
   history::URLRows new_sync_entries;
   GetTypedUrlsFromSyncDB(&new_sync_entries);
   ASSERT_EQ(1U, new_sync_entries.size());
   EXPECT_TRUE(URLsEqual(added_entry, new_sync_entries[0]));
 }
 
 TEST_F(ProfileSyncServiceTypedUrlTest, ProcessUserChangeAddWithBlank) {
   history::VisitVector added_visits;
-  history::URLRow empty_entry(MakeTypedUrlEntry("", "entry",
-                                                2, 15, false, &added_visits));
-  history::URLRow added_entry(MakeTypedUrlEntry("http://added.com", "entry",
-                                                2, 15, false, &added_visits));
+  history::URLRow empty_entry(
+      MakeTypedUrlEntry("", "entry", 2, 15, false, &added_visits));
+  history::URLRow added_entry(MakeTypedUrlEntry("http://added.com", "entry", 2,
+                                                15, false, &added_visits));
 
   EXPECT_CALL((history_backend()), GetAllTypedURLs(_)).WillOnce(Return(true));
   EXPECT_CALL((history_backend()), GetMostRecentVisitsForURL(_, _, _))
       .WillRepeatedly(DoAll(SetArgumentPointee<2>(added_visits), Return(true)));
 
   SetIdleChangeProcessorExpectations();
   CreateRootHelper create_root(this, syncer::TYPED_URLS);
   StartSyncService(create_root.callback());
 
   history::URLRows changed_urls;
   changed_urls.push_back(empty_entry);
   changed_urls.push_back(added_entry);
   SendNotificationURLsModified(changed_urls);
 
   std::vector<history::URLRow> new_sync_entries;
   GetTypedUrlsFromSyncDB(&new_sync_entries);
   ASSERT_EQ(1U, new_sync_entries.size());
   EXPECT_TRUE(URLsEqual(added_entry, new_sync_entries[0]));
 }
 
 TEST_F(ProfileSyncServiceTypedUrlTest, ProcessUserChangeUpdate) {
   history::VisitVector original_visits;
-  history::URLRow original_entry(MakeTypedUrlEntry("http://mine.com", "entry",
-                                                   2, 15, false,
-                                                   &original_visits));
+  history::URLRow original_entry(MakeTypedUrlEntry(
+      "http://mine.com", "entry", 2, 15, false, &original_visits));
   history::URLRows original_entries;
   original_entries.push_back(original_entry);
 
   EXPECT_CALL((history_backend()), GetAllTypedURLs(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(original_entries), Return(true)));
   EXPECT_CALL((history_backend()), GetMostRecentVisitsForURL(_, _, _))
       .WillOnce(DoAll(SetArgumentPointee<2>(original_visits), Return(true)));
   CreateRootHelper create_root(this, syncer::TYPED_URLS);
   StartSyncService(create_root.callback());
 
   history::VisitVector updated_visits;
-  history::URLRow updated_entry(MakeTypedUrlEntry("http://mine.com", "entry",
-                                                  7, 17, false,
-                                                  &updated_visits));
+  history::URLRow updated_entry(MakeTypedUrlEntry("http://mine.com", "entry", 7,
+                                                  17, false, &updated_visits));
   EXPECT_CALL((history_backend()), GetMostRecentVisitsForURL(_, _, _))
       .WillOnce(DoAll(SetArgumentPointee<2>(updated_visits), Return(true)));
 
   history::URLRows changed_urls;
   changed_urls.push_back(updated_entry);
   SendNotificationURLsModified(changed_urls);
 
   history::URLRows new_sync_entries;
   GetTypedUrlsFromSyncDB(&new_sync_entries);
   ASSERT_EQ(1U, new_sync_entries.size());
   EXPECT_TRUE(URLsEqual(updated_entry, new_sync_entries[0]));
 }
 
 TEST_F(ProfileSyncServiceTypedUrlTest, ProcessUserChangeAddFromVisit) {
   history::VisitVector added_visits;
-  history::URLRow added_entry(MakeTypedUrlEntry("http://added.com", "entry",
-                                                2, 15, false, &added_visits));
+  history::URLRow added_entry(MakeTypedUrlEntry("http://added.com", "entry", 2,
+                                                15, false, &added_visits));
 
   EXPECT_CALL((history_backend()), GetAllTypedURLs(_)).WillOnce(Return(true));
   EXPECT_CALL((history_backend()), GetMostRecentVisitsForURL(_, _, _))
       .WillOnce(DoAll(SetArgumentPointee<2>(added_visits), Return(true)));
 
   SetIdleChangeProcessorExpectations();
   CreateRootHelper create_root(this, syncer::TYPED_URLS);
   StartSyncService(create_root.callback());
 
   SendNotificationURLVisited(ui::PAGE_TRANSITION_TYPED, added_entry);
 
   history::URLRows new_sync_entries;
   GetTypedUrlsFromSyncDB(&new_sync_entries);
   ASSERT_EQ(1U, new_sync_entries.size());
   EXPECT_TRUE(URLsEqual(added_entry, new_sync_entries[0]));
 }
 
 TEST_F(ProfileSyncServiceTypedUrlTest, ProcessUserChangeUpdateFromVisit) {
   history::VisitVector original_visits;
-  history::URLRow original_entry(MakeTypedUrlEntry("http://mine.com", "entry",
-                                                   2, 15, false,
-                                                   &original_visits));
+  history::URLRow original_entry(MakeTypedUrlEntry(
+      "http://mine.com", "entry", 2, 15, false, &original_visits));
   history::URLRows original_entries;
   original_entries.push_back(original_entry);
 
   EXPECT_CALL((history_backend()), GetAllTypedURLs(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(original_entries), Return(true)));
   EXPECT_CALL((history_backend()), GetMostRecentVisitsForURL(_, _, _))
       .WillOnce(DoAll(SetArgumentPointee<2>(original_visits), Return(true)));
   CreateRootHelper create_root(this, syncer::TYPED_URLS);
   StartSyncService(create_root.callback());
 
   history::VisitVector updated_visits;
-  history::URLRow updated_entry(MakeTypedUrlEntry("http://mine.com", "entry",
-                                                  7, 17, false,
-                                                  &updated_visits));
+  history::URLRow updated_entry(MakeTypedUrlEntry("http://mine.com", "entry", 7,
+                                                  17, false, &updated_visits));
   EXPECT_CALL((history_backend()), GetMostRecentVisitsForURL(_, _, _))
       .WillOnce(DoAll(SetArgumentPointee<2>(updated_visits), Return(true)));
 
   SendNotificationURLVisited(ui::PAGE_TRANSITION_TYPED, updated_entry);
 
   history::URLRows new_sync_entries;
   GetTypedUrlsFromSyncDB(&new_sync_entries);
   ASSERT_EQ(1U, new_sync_entries.size());
   EXPECT_TRUE(URLsEqual(updated_entry, new_sync_entries[0]));
 }
 
 TEST_F(ProfileSyncServiceTypedUrlTest, ProcessUserIgnoreChangeUpdateFromVisit) {
   history::VisitVector original_visits;
-  history::URLRow original_entry(MakeTypedUrlEntry("http://mine.com", "entry",
-                                                   2, 15, false,
-                                                   &original_visits));
+  history::URLRow original_entry(MakeTypedUrlEntry(
+      "http://mine.com", "entry", 2, 15, false, &original_visits));
   history::URLRows original_entries;
   original_entries.push_back(original_entry);
 
   EXPECT_CALL((history_backend()), GetAllTypedURLs(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(original_entries), Return(true)));
   EXPECT_CALL((history_backend()), GetMostRecentVisitsForURL(_, _, _))
       .WillRepeatedly(
           DoAll(SetArgumentPointee<2>(original_visits), Return(true)));
   CreateRootHelper create_root(this, syncer::TYPED_URLS);
   StartSyncService(create_root.callback());
   history::URLRows new_sync_entries;
   GetTypedUrlsFromSyncDB(&new_sync_entries);
   ASSERT_EQ(1U, new_sync_entries.size());
   EXPECT_TRUE(URLsEqual(original_entry, new_sync_entries[0]));
 
   history::VisitVector updated_visits;
-  history::URLRow updated_entry(MakeTypedUrlEntry("http://mine.com", "entry",
-                                                  7, 15, false,
-                                                  &updated_visits));
+  history::URLRow updated_entry(MakeTypedUrlEntry("http://mine.com", "entry", 7,
+                                                  15, false, &updated_visits));
 
   // Should ignore this change because it's not TYPED.
   SendNotificationURLVisited(ui::PAGE_TRANSITION_RELOAD, updated_entry);
   GetTypedUrlsFromSyncDB(&new_sync_entries);
 
   // Should be no changes to the sync DB from this notification.
   ASSERT_EQ(1U, new_sync_entries.size());
   EXPECT_TRUE(URLsEqual(original_entry, new_sync_entries[0]));
 
   // Now, try updating it with a large number of visits not divisible by 10
   // (should ignore this visit).
-  history::URLRow twelve_visits(MakeTypedUrlEntry("http://mine.com", "entry",
-                                                  12, 15, false,
-                                                  &updated_visits));
+  history::URLRow twelve_visits(MakeTypedUrlEntry(
+      "http://mine.com", "entry", 12, 15, false, &updated_visits));
   SendNotificationURLVisited(ui::PAGE_TRANSITION_TYPED, twelve_visits);
   GetTypedUrlsFromSyncDB(&new_sync_entries);
 
   // Should be no changes to the sync DB from this notification.
   ASSERT_EQ(1U, new_sync_entries.size());
   EXPECT_TRUE(URLsEqual(original_entry, new_sync_entries[0]));
 
   // Now, try updating it with a large number of visits that is divisible by 10
   // (should *not* be ignored).
-  history::URLRow twenty_visits(MakeTypedUrlEntry("http://mine.com", "entry",
-                                                  20, 15, false,
-                                                  &updated_visits));
+  history::URLRow twenty_visits(MakeTypedUrlEntry(
+      "http://mine.com", "entry", 20, 15, false, &updated_visits));
   SendNotificationURLVisited(ui::PAGE_TRANSITION_TYPED, twenty_visits);
   GetTypedUrlsFromSyncDB(&new_sync_entries);
 
   ASSERT_EQ(1U, new_sync_entries.size());
   EXPECT_TRUE(URLsEqual(twenty_visits, new_sync_entries[0]));
 }
 
 TEST_F(ProfileSyncServiceTypedUrlTest, ProcessUserChangeRemove) {
   history::VisitVector original_visits1;
-  history::URLRow original_entry1(MakeTypedUrlEntry("http://mine.com", "entry",
-                                                    2, 15, false,
-                                                    &original_visits1));
+  history::URLRow original_entry1(MakeTypedUrlEntry(
+      "http://mine.com", "entry", 2, 15, false, &original_visits1));
   history::VisitVector original_visits2;
-  history::URLRow original_entry2(MakeTypedUrlEntry("http://mine2.com",
-                                                    "entry2",
-                                                    3, 15, false,
-                                                    &original_visits2));
+  history::URLRow original_entry2(MakeTypedUrlEntry(
+      "http://mine2.com", "entry2", 3, 15, false, &original_visits2));
   history::URLRows original_entries;
   original_entries.push_back(original_entry1);
   original_entries.push_back(original_entry2);
 
   EXPECT_CALL((history_backend()), GetAllTypedURLs(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(original_entries), Return(true)));
   EXPECT_CALL((history_backend()), GetMostRecentVisitsForURL(_, _, _))
       .WillRepeatedly(
           DoAll(SetArgumentPointee<2>(original_visits1), Return(true)));
   CreateRootHelper create_root(this, syncer::TYPED_URLS);
   StartSyncService(create_root.callback());
 
   history::URLRows rows;
   rows.push_back(history::URLRow(GURL("http://mine.com")));
   SendNotificationURLsDeleted(false, false, rows, std::set<GURL>());
   history::URLRows new_sync_entries;
   GetTypedUrlsFromSyncDB(&new_sync_entries);
   ASSERT_EQ(1U, new_sync_entries.size());
   EXPECT_TRUE(URLsEqual(original_entry2, new_sync_entries[0]));
 }
 
 TEST_F(ProfileSyncServiceTypedUrlTest, ProcessUserChangeRemoveExpired) {
   history::VisitVector original_visits1;
-  history::URLRow original_entry1(MakeTypedUrlEntry("http://mine.com", "entry",
-                                                    2, 15, false,
-                                                    &original_visits1));
+  history::URLRow original_entry1(MakeTypedUrlEntry(
+      "http://mine.com", "entry", 2, 15, false, &original_visits1));
   history::VisitVector original_visits2;
-  history::URLRow original_entry2(MakeTypedUrlEntry("http://mine2.com",
-                                                    "entry2",
-                                                    3, 15, false,
-                                                    &original_visits2));
+  history::URLRow original_entry2(MakeTypedUrlEntry(
+      "http://mine2.com", "entry2", 3, 15, false, &original_visits2));
   history::URLRows original_entries;
   original_entries.push_back(original_entry1);
   original_entries.push_back(original_entry2);
 
   EXPECT_CALL((history_backend()), GetAllTypedURLs(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(original_entries), Return(true)));
   EXPECT_CALL((history_backend()), GetMostRecentVisitsForURL(_, _, _))
       .WillRepeatedly(
           DoAll(SetArgumentPointee<2>(original_visits1), Return(true)));
   CreateRootHelper create_root(this, syncer::TYPED_URLS);
   StartSyncService(create_root.callback());
 
   // Setting expired=true should cause the sync code to ignore this deletion.
   history::URLRows rows;
   rows.push_back(history::URLRow(GURL("http://mine.com")));
   SendNotificationURLsDeleted(false, true, rows, std::set<GURL>());
   history::URLRows new_sync_entries;
   GetTypedUrlsFromSyncDB(&new_sync_entries);
   // Both URLs should still be there.
   ASSERT_EQ(2U, new_sync_entries.size());
 }
 
 TEST_F(ProfileSyncServiceTypedUrlTest, ProcessUserChangeRemoveAll) {
   history::VisitVector original_visits1;
-  history::URLRow original_entry1(MakeTypedUrlEntry("http://mine.com", "entry",
-                                                    2, 15, false,
-                                                    &original_visits1));
+  history::URLRow original_entry1(MakeTypedUrlEntry(
+      "http://mine.com", "entry", 2, 15, false, &original_visits1));
   history::VisitVector original_visits2;
-  history::URLRow original_entry2(MakeTypedUrlEntry("http://mine2.com",
-                                                    "entry2",
-                                                    3, 15, false,
-                                                    &original_visits2));
+  history::URLRow original_entry2(MakeTypedUrlEntry(
+      "http://mine2.com", "entry2", 3, 15, false, &original_visits2));
   history::URLRows original_entries;
   original_entries.push_back(original_entry1);
   original_entries.push_back(original_entry2);
 
   EXPECT_CALL((history_backend()), GetAllTypedURLs(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(original_entries), Return(true)));
   EXPECT_CALL((history_backend()), GetMostRecentVisitsForURL(_, _, _))
       .WillRepeatedly(
           DoAll(SetArgumentPointee<2>(original_visits1), Return(true)));
   CreateRootHelper create_root(this, syncer::TYPED_URLS);
   StartSyncService(create_root.callback());
 
   history::URLRows new_sync_entries;
   GetTypedUrlsFromSyncDB(&new_sync_entries);
   ASSERT_EQ(2U, new_sync_entries.size());
 
   SendNotificationURLsDeleted(true, false, history::URLRows(),
                               std::set<GURL>());
 
   GetTypedUrlsFromSyncDB(&new_sync_entries);
   ASSERT_EQ(0U, new_sync_entries.size());
 }
 
 TEST_F(ProfileSyncServiceTypedUrlTest, FailWriteToHistoryBackend) {
   history::VisitVector native_visits;
   history::VisitVector sync_visits;
   history::URLRow native_entry(MakeTypedUrlEntry("http://native.com", "entry",
                                                  2, 15, false, &native_visits));
-  history::URLRow sync_entry(MakeTypedUrlEntry("http://sync.com", "entry",
-                                               3, 16, false, &sync_visits));
+  history::URLRow sync_entry(MakeTypedUrlEntry("http://sync.com", "entry", 3,
+                                               16, false, &sync_visits));
 
   history::URLRows native_entries;
   native_entries.push_back(native_entry);
   EXPECT_CALL((history_backend()), GetAllTypedURLs(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(native_entries), Return(true)));
   EXPECT_CALL((history_backend()), GetURL(_, _))
       .WillOnce(DoAll(SetArgumentPointee<1>(native_entry), Return(false)));
   EXPECT_CALL((history_backend()), GetMostRecentVisitsForURL(_, _, _))
       .WillRepeatedly(
           DoAll(SetArgumentPointee<2>(native_visits), Return(true)));
@@ skipping 15 matching lines @@
   // somewhere > 0 and < 100.
   ASSERT_NE(0, syncable_service->GetErrorPercentage());
   ASSERT_NE(100, syncable_service->GetErrorPercentage());
 }
 
 TEST_F(ProfileSyncServiceTypedUrlTest, FailToGetTypedURLs) {
   history::VisitVector native_visits;
   history::VisitVector sync_visits;
   history::URLRow native_entry(MakeTypedUrlEntry("http://native.com", "entry",
                                                  2, 15, false, &native_visits));
-  history::URLRow sync_entry(MakeTypedUrlEntry("http://sync.com", "entry",
-                                               3, 16, false, &sync_visits));
+  history::URLRow sync_entry(MakeTypedUrlEntry("http://sync.com", "entry", 3,
+                                               16, false, &sync_visits));
 
   history::URLRows native_entries;
   native_entries.push_back(native_entry);
   EXPECT_CALL((history_backend()), GetAllTypedURLs(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(native_entries), Return(false)));
 
   history::URLRows sync_entries;
   sync_entries.push_back(sync_entry);
 
   StartSyncService(base::Bind(&AddTypedUrlEntries, this, sync_entries));
   // Errors getting typed URLs will cause an unrecoverable error (since we can
   // do *nothing* in that case).
   ASSERT_TRUE(sync_service()->data_type_status_table().GetFailedTypes().Has(
       syncer::TYPED_URLS));
   ASSERT_EQ(1u,
             sync_service()->data_type_status_table().GetFailedTypes().Size());
   // Can't check GetErrorPercentage(), because generating an unrecoverable
   // error will free the model associator.
 }
 
 TEST_F(ProfileSyncServiceTypedUrlTest, IgnoreLocalFileURL) {
   history::VisitVector original_visits;
   // Create http and file url.
-  history::URLRow url_entry(MakeTypedUrlEntry("http://yey.com",
-                                              "yey", 12, 15, false,
-                                              &original_visits));
-  history::URLRow file_entry(MakeTypedUrlEntry("file:///kitty.jpg",
-                                               "kitteh", 12, 15, false,
-                                               &original_visits));
+  history::URLRow url_entry(MakeTypedUrlEntry("http://yey.com", "yey", 12, 15,
+                                              false, &original_visits));
+  history::URLRow file_entry(MakeTypedUrlEntry(
+      "file:///kitty.jpg", "kitteh", 12, 15, false, &original_visits));
 
   history::URLRows original_entries;
   original_entries.push_back(url_entry);
   original_entries.push_back(file_entry);
 
   EXPECT_CALL((history_backend()), GetAllTypedURLs(_))
       .WillRepeatedly(
           DoAll(SetArgumentPointee<0>(original_entries), Return(true)));
   EXPECT_CALL((history_backend()), GetMostRecentVisitsForURL(_, _, _))
       .WillRepeatedly(
           DoAll(SetArgumentPointee<2>(original_visits), Return(true)));
   CreateRootHelper create_root(this, syncer::TYPED_URLS);
   StartSyncService(create_root.callback());
 
   history::VisitVector updated_visits;
   // Create updates for the previous urls + a new file one.
-  history::URLRow updated_url_entry(MakeTypedUrlEntry("http://yey.com",
-                                                      "yey", 20, 15, false,
-                                                      &updated_visits));
-  history::URLRow updated_file_entry(MakeTypedUrlEntry("file:///cat.jpg",
-                                                       "cat", 20, 15, false,
-                                                       &updated_visits));
-  history::URLRow new_file_entry(MakeTypedUrlEntry("file:///dog.jpg",
-                                                   "dog", 20, 15, false,
-                                                   &updated_visits));
+  history::URLRow updated_url_entry(MakeTypedUrlEntry(
+      "http://yey.com", "yey", 20, 15, false, &updated_visits));
+  history::URLRow updated_file_entry(MakeTypedUrlEntry(
+      "file:///cat.jpg", "cat", 20, 15, false, &updated_visits));
+  history::URLRow new_file_entry(MakeTypedUrlEntry("file:///dog.jpg", "dog", 20,
+                                                   15, false, &updated_visits));
 
   history::URLRows changed_urls;
   changed_urls.push_back(updated_url_entry);
   changed_urls.push_back(updated_file_entry);
   changed_urls.push_back(new_file_entry);
   SendNotificationURLsModified(changed_urls);
 
   history::URLRows new_sync_entries;
   GetTypedUrlsFromSyncDB(&new_sync_entries);
 
   // We should ignore the local file urls (existing and updated),
   // and only be left with the updated http url.
   ASSERT_EQ(1U, new_sync_entries.size());
   EXPECT_TRUE(URLsEqual(updated_url_entry, new_sync_entries[0]));
 }
 
 TEST_F(ProfileSyncServiceTypedUrlTest, IgnoreLocalhostURL) {
   history::VisitVector original_visits;
   // Create http and localhost url.
-  history::URLRow url_entry(MakeTypedUrlEntry("http://yey.com",
-                                              "yey", 12, 15, false,
-                                              &original_visits));
-  history::URLRow localhost_entry(MakeTypedUrlEntry("http://localhost",
-                                              "localhost", 12, 15, false,
-                                              &original_visits));
+  history::URLRow url_entry(MakeTypedUrlEntry("http://yey.com", "yey", 12, 15,
+                                              false, &original_visits));
+  history::URLRow localhost_entry(MakeTypedUrlEntry(
+      "http://localhost", "localhost", 12, 15, false, &original_visits));
 
   history::URLRows original_entries;
   original_entries.push_back(url_entry);
   original_entries.push_back(localhost_entry);
 
   EXPECT_CALL((history_backend()), GetAllTypedURLs(_))
       .WillRepeatedly(
           DoAll(SetArgumentPointee<0>(original_entries), Return(true)));
   EXPECT_CALL((history_backend()), GetMostRecentVisitsForURL(_, _, _))
       .WillRepeatedly(
           DoAll(SetArgumentPointee<2>(original_visits), Return(true)));
   CreateRootHelper create_root(this, syncer::TYPED_URLS);
   StartSyncService(create_root.callback());
 
   history::VisitVector updated_visits;
   // Update the previous entries and add a new localhost.
-  history::URLRow updated_url_entry(MakeTypedUrlEntry("http://yey.com",
-                                                  "yey", 20, 15, false,
-                                                  &updated_visits));
+  history::URLRow updated_url_entry(MakeTypedUrlEntry(
+      "http://yey.com", "yey", 20, 15, false, &updated_visits));
   history::URLRow updated_localhost_entry(MakeTypedUrlEntry(
-                                                  "http://localhost:80",
-                                                  "localhost", 20, 15, false,
-                                                  &original_visits));
-  history::URLRow localhost_ip_entry(MakeTypedUrlEntry("http://127.0.0.1",
-                                                  "localhost", 12, 15, false,
-                                                  &original_visits));
+      "http://localhost:80", "localhost", 20, 15, false, &original_visits));
+  history::URLRow localhost_ip_entry(MakeTypedUrlEntry(
+      "http://127.0.0.1", "localhost", 12, 15, false, &original_visits));
 
   history::URLRows changed_urls;
   changed_urls.push_back(updated_url_entry);
   changed_urls.push_back(updated_localhost_entry);
   changed_urls.push_back(localhost_ip_entry);
   SendNotificationURLsModified(changed_urls);
 
   history::URLRows new_sync_entries;
   GetTypedUrlsFromSyncDB(&new_sync_entries);
 
   // We should ignore the localhost urls and left only with http url.
   ASSERT_EQ(1U, new_sync_entries.size());
   EXPECT_TRUE(URLsEqual(updated_url_entry, new_sync_entries[0]));
 }
 
 TEST_F(ProfileSyncServiceTypedUrlTest, IgnoreModificationWithoutValidVisit) {
   EXPECT_CALL((history_backend()), GetAllTypedURLs(_))
       .WillRepeatedly(Return(true));
   EXPECT_CALL((history_backend()), GetMostRecentVisitsForURL(_, _, _))
       .WillRepeatedly(Return(true));
 
   CreateRootHelper create_root(this, syncer::TYPED_URLS);
   StartSyncService(create_root.callback());
 
   history::VisitVector updated_visits;
-  history::URLRow updated_url_entry(MakeTypedUrlEntry("http://yey.com",
-                                                  "yey", 20, 0, false,
-                                                  &updated_visits));
+  history::URLRow updated_url_entry(MakeTypedUrlEntry(
+      "http://yey.com", "yey", 20, 0, false, &updated_visits));
 
   history::URLRows changed_urls;
   changed_urls.push_back(updated_url_entry);
   SendNotificationURLsModified(changed_urls);
 
   history::URLRows new_sync_entries;
   GetTypedUrlsFromSyncDB(&new_sync_entries);
 
   // The change should be ignored.
   ASSERT_EQ(0U, new_sync_entries.size());
 }