1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "chrome/browser/history/typed_url_syncable_service.h" 6 7 #include "base/logging.h" 8 #include "base/memory/ref_counted.h" 9 #include "base/memory/scoped_ptr.h" 10 #include "base/strings/utf_string_conversions.h" 11 #include "chrome/browser/history/history_backend.h" 12 #include "chrome/browser/history/history_types.h" 13 #include "content/public/browser/notification_types.h" 14 #include "sync/api/sync_error.h" 15 #include "sync/api/sync_error_factory_mock.h" 16 #include "sync/protocol/sync.pb.h" 17 #include "sync/protocol/typed_url_specifics.pb.h" 18 #include "testing/gtest/include/gtest/gtest.h" 19 20 using history::HistoryBackend; 21 using history::URLID; 22 using history::URLRow; 23 using history::URLRows; 24 using history::VisitRow; 25 using history::VisitVector; 26 27 namespace { 28 29 // Constants used to limit size of visits processed. 30 const int kMaxTypedUrlVisits = 100; 31 32 // Visits with this timestamp are treated as expired. 33 const int EXPIRED_VISIT = -1; 34 35 // TestChangeProcessor -------------------------------------------------------- 36 37 class TestChangeProcessor : public syncer::SyncChangeProcessor { 38 public: 39 TestChangeProcessor() : change_output_(NULL) {} 40 41 // syncer::SyncChangeProcessor implementation. 42 virtual syncer::SyncError ProcessSyncChanges( 43 const tracked_objects::Location& from_here, 44 const syncer::SyncChangeList& change_list) OVERRIDE { 45 change_output_->insert(change_output_->end(), change_list.begin(), 46 change_list.end()); 47 return syncer::SyncError(); 48 } 49 50 virtual syncer::SyncDataList GetAllSyncData(syncer::ModelType type) const 51 OVERRIDE { 52 return syncer::SyncDataList(); 53 } 54 55 // Set pointer location to write SyncChanges to in ProcessSyncChanges. 56 void SetChangeOutput(syncer::SyncChangeList *change_output) { 57 change_output_ = change_output; 58 } 59 60 private: 61 syncer::SyncChangeList *change_output_; 62 63 DISALLOW_COPY_AND_ASSIGN(TestChangeProcessor); 64 }; 65 66 // TestHistoryBackend ---------------------------------------------------------- 67 68 class TestHistoryBackend : public HistoryBackend { 69 public: 70 TestHistoryBackend() : HistoryBackend(base::FilePath(), 0, NULL, NULL) {} 71 72 // HistoryBackend test implementation. 73 virtual bool IsExpiredVisitTime(const base::Time& time) OVERRIDE { 74 return time.ToInternalValue() == EXPIRED_VISIT; 75 } 76 77 virtual bool GetMostRecentVisitsForURL( 78 URLID id, 79 int max_visits, 80 VisitVector* visits) OVERRIDE { 81 if (local_db_visits_[id].empty()) 82 return false; 83 84 visits->insert(visits->end(), 85 local_db_visits_[id].begin(), 86 local_db_visits_[id].end()); 87 return true; 88 } 89 90 // Helpers. 91 void SetVisitsForUrl(URLID id, VisitVector* visits) { 92 if (!local_db_visits_[id].empty()) { 93 local_db_visits_[id].clear(); 94 } 95 96 local_db_visits_[id].insert(local_db_visits_[id].end(), 97 visits->begin(), 98 visits->end()); 99 } 100 101 void DeleteVisitsForUrl(const URLID& id) { 102 local_db_visits_.erase(id); 103 } 104 105 private: 106 virtual ~TestHistoryBackend() {} 107 108 // Mock of visit table in local db. 109 std::map<URLID, VisitVector> local_db_visits_; 110 }; 111 112 } // namespace 113 114 namespace history { 115 116 // TypedUrlSyncableServiceTest ------------------------------------------------- 117 118 class TypedUrlSyncableServiceTest : public testing::Test { 119 public: 120 // Create a new row object and add a typed visit to the |visits| vector. 121 // Note that the real history db returns visits in reverse chronological 122 // order, so |visits| is treated this way. If the newest (first) visit 123 // in visits does not match |last_visit|, then a typed visit for this 124 // time is prepended to the front (or if |last_visit| is too old, it is 125 // set equal to the time of the newest visit). 126 static URLRow MakeTypedUrlRow(const char* url, 127 const char* title, 128 int typed_count, 129 int64 last_visit, 130 bool hidden, 131 VisitVector* visits); 132 133 static void AddNewestVisit(URLRow* url, 134 VisitVector* visits, 135 content::PageTransition transition, 136 int64 visit_time); 137 138 static void AddOldestVisit(URLRow* url, 139 VisitVector* visits, 140 content::PageTransition transition, 141 int64 visit_time); 142 143 static bool URLsEqual(URLRow& row, 144 sync_pb::TypedUrlSpecifics& specifics) { 145 return ((row.url().spec().compare(specifics.url()) == 0) && 146 (UTF16ToUTF8(row.title()).compare(specifics.title()) == 0) && 147 (row.hidden() == specifics.hidden())); 148 } 149 150 bool InitiateServerState( 151 unsigned int num_typed_urls, 152 unsigned int num_reload_urls, 153 URLRows* rows, 154 std::vector<VisitVector>* visit_vectors, 155 const std::vector<const char*>& urls, 156 syncer::SyncChangeList* change_list); 157 158 protected: 159 TypedUrlSyncableServiceTest() {} 160 161 virtual ~TypedUrlSyncableServiceTest() {} 162 163 virtual void SetUp() OVERRIDE { 164 fake_history_backend_ = new TestHistoryBackend(); 165 typed_url_sync_service_.reset( 166 new TypedUrlSyncableService(fake_history_backend_.get())); 167 fake_change_processor_.reset(new TestChangeProcessor); 168 } 169 170 scoped_refptr<HistoryBackend> fake_history_backend_; 171 scoped_ptr<TypedUrlSyncableService> typed_url_sync_service_; 172 scoped_ptr<syncer::SyncChangeProcessor> fake_change_processor_; 173 }; 174 175 URLRow TypedUrlSyncableServiceTest::MakeTypedUrlRow( 176 const char* url, 177 const char* title, 178 int typed_count, 179 int64 last_visit, 180 bool hidden, 181 VisitVector* visits) { 182 DCHECK(visits->empty()); 183 184 // Give each URL a unique ID, to mimic the behavior of the real database. 185 static int unique_url_id = 0; 186 GURL gurl(url); 187 URLRow history_url(gurl, ++unique_url_id); 188 history_url.set_title(UTF8ToUTF16(title)); 189 history_url.set_typed_count(typed_count); 190 history_url.set_hidden(hidden); 191 192 base::Time last_visit_time = base::Time::FromInternalValue(last_visit); 193 history_url.set_last_visit(last_visit_time); 194 195 VisitVector::iterator first = visits->begin(); 196 if (typed_count > 0) { 197 // Add a typed visit for time |last_visit|. 198 visits->insert(first, 199 VisitRow(history_url.id(), last_visit_time, 0, 200 content::PAGE_TRANSITION_TYPED, 0)); 201 } else { 202 // Add a non-typed visit for time |last_visit|. 203 visits->insert(first, 204 VisitRow(history_url.id(), last_visit_time, 0, 205 content::PAGE_TRANSITION_RELOAD, 0)); 206 } 207 208 history_url.set_visit_count(visits->size()); 209 return history_url; 210 } 211 212 void TypedUrlSyncableServiceTest::AddNewestVisit( 213 URLRow* url, 214 VisitVector* visits, 215 content::PageTransition transition, 216 int64 visit_time) { 217 base::Time time = base::Time::FromInternalValue(visit_time); 218 visits->insert(visits->begin(), 219 VisitRow(url->id(), time, 0, transition, 0)); 220 221 if (transition == content::PAGE_TRANSITION_TYPED) { 222 url->set_typed_count(url->typed_count() + 1); 223 } 224 225 url->set_last_visit(time); 226 url->set_visit_count(visits->size()); 227 } 228 229 void TypedUrlSyncableServiceTest::AddOldestVisit( 230 URLRow* url, 231 VisitVector* visits, 232 content::PageTransition transition, 233 int64 visit_time) { 234 base::Time time = base::Time::FromInternalValue(visit_time); 235 visits->push_back(VisitRow(url->id(), time, 0, transition, 0)); 236 237 if (transition == content::PAGE_TRANSITION_TYPED) { 238 url->set_typed_count(url->typed_count() + 1); 239 } 240 241 url->set_visit_count(visits->size()); 242 } 243 244 bool TypedUrlSyncableServiceTest::InitiateServerState( 245 unsigned int num_typed_urls, 246 unsigned int num_reload_urls, 247 URLRows* rows, 248 std::vector<VisitVector>* visit_vectors, 249 const std::vector<const char*>& urls, 250 syncer::SyncChangeList* change_list) { 251 unsigned int total_urls = num_typed_urls + num_reload_urls; 252 DCHECK(urls.size() >= total_urls); 253 if (!typed_url_sync_service_.get()) 254 return false; 255 256 static_cast<TestChangeProcessor*>(fake_change_processor_.get())-> 257 SetChangeOutput(change_list); 258 259 // Set change processor. 260 syncer::SyncMergeResult result = 261 typed_url_sync_service_->MergeDataAndStartSyncing( 262 syncer::TYPED_URLS, 263 syncer::SyncDataList(), 264 fake_change_processor_.Pass(), 265 scoped_ptr<syncer::SyncErrorFactory>( 266 new syncer::SyncErrorFactoryMock())); 267 EXPECT_FALSE(result.error().IsSet()) << result.error().message(); 268 269 if (total_urls) { 270 // Create new URL rows, populate the mock backend with its visits, and 271 // send to the sync service. 272 URLRows changed_urls; 273 274 for (unsigned int i = 0; i < total_urls; ++i) { 275 int typed = i < num_typed_urls ? 1 : 0; 276 VisitVector visits; 277 visit_vectors->push_back(visits); 278 rows->push_back(MakeTypedUrlRow( 279 urls[i], "pie", typed, i + 3, false, &visit_vectors->back())); 280 static_cast<TestHistoryBackend*>(fake_history_backend_.get())-> 281 SetVisitsForUrl(rows->back().id(), &visit_vectors->back()); 282 changed_urls.push_back(rows->back()); 283 } 284 285 typed_url_sync_service_->OnUrlsModified(&changed_urls); 286 } 287 // Check that communication with sync was successful. 288 if (num_typed_urls != change_list->size()) 289 return false; 290 return true; 291 } 292 293 TEST_F(TypedUrlSyncableServiceTest, AddLocalTypedUrlAndSync) { 294 // Create a local typed URL (simulate a typed visit) that is not already 295 // in sync. Check that sync is sent an ADD change for the existing URL. 296 syncer::SyncChangeList change_list; 297 298 URLRows url_rows; 299 std::vector<VisitVector> visit_vectors; 300 std::vector<const char*> urls; 301 urls.push_back("http://pie.com/"); 302 303 ASSERT_TRUE( 304 InitiateServerState(1, 0, &url_rows, &visit_vectors, urls, &change_list)); 305 306 URLRow url_row = url_rows.front(); 307 VisitVector visits = visit_vectors.front(); 308 309 // Check change processor. 310 ASSERT_EQ(1u, change_list.size()); 311 ASSERT_TRUE(change_list[0].IsValid()); 312 EXPECT_EQ(syncer::TYPED_URLS, change_list[0].sync_data().GetDataType()); 313 EXPECT_EQ(syncer::SyncChange::ACTION_ADD, change_list[0].change_type()); 314 315 // Get typed url specifics. 316 sync_pb::TypedUrlSpecifics url_specifics = 317 change_list[0].sync_data().GetSpecifics().typed_url(); 318 319 EXPECT_TRUE(URLsEqual(url_row, url_specifics)); 320 ASSERT_EQ(1, url_specifics.visits_size()); 321 ASSERT_EQ(static_cast<const int>(visits.size()), url_specifics.visits_size()); 322 EXPECT_EQ(visits[0].visit_time.ToInternalValue(), url_specifics.visits(0)); 323 EXPECT_EQ(static_cast<const int>(visits[0].transition), 324 url_specifics.visit_transitions(0)); 325 326 // Check that in-memory representation of sync state is accurate. 327 std::set<GURL> sync_state; 328 typed_url_sync_service_.get()->GetSyncedUrls(&sync_state); 329 EXPECT_FALSE(sync_state.empty()); 330 EXPECT_EQ(1u, sync_state.size()); 331 EXPECT_TRUE(sync_state.end() != sync_state.find(url_row.url())); 332 } 333 334 TEST_F(TypedUrlSyncableServiceTest, UpdateLocalTypedUrlAndSync) { 335 syncer::SyncChangeList change_list; 336 337 URLRows url_rows; 338 std::vector<VisitVector> visit_vectors; 339 std::vector<const char*> urls; 340 urls.push_back("http://pie.com/"); 341 342 ASSERT_TRUE( 343 InitiateServerState(1, 0, &url_rows, &visit_vectors, urls, &change_list)); 344 change_list.clear(); 345 346 // Update the URL row, adding another typed visit to the visit vector. 347 URLRow url_row = url_rows.front(); 348 VisitVector visits = visit_vectors.front(); 349 350 URLRows changed_urls; 351 AddNewestVisit(&url_row, &visits, content::PAGE_TRANSITION_TYPED, 7); 352 static_cast<TestHistoryBackend*>(fake_history_backend_.get())-> 353 SetVisitsForUrl(url_row.id(), &visits); 354 changed_urls.push_back(url_row); 355 356 // Notify typed url sync service of the update. 357 typed_url_sync_service_->OnUrlsModified(&changed_urls); 358 359 ASSERT_EQ(1u, change_list.size()); 360 ASSERT_TRUE(change_list[0].IsValid()); 361 EXPECT_EQ(syncer::TYPED_URLS, change_list[0].sync_data().GetDataType()); 362 EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, change_list[0].change_type()); 363 364 sync_pb::TypedUrlSpecifics url_specifics = 365 change_list[0].sync_data().GetSpecifics().typed_url(); 366 367 EXPECT_TRUE(URLsEqual(url_row, url_specifics)); 368 ASSERT_EQ(2, url_specifics.visits_size()); 369 ASSERT_EQ(static_cast<const int>(visits.size()), url_specifics.visits_size()); 370 371 // Check that each visit has been translated/communicated correctly. 372 // Note that the specifics record visits in chronological order, and the 373 // visits from the db are in reverse chronological order. 374 EXPECT_EQ(visits[0].visit_time.ToInternalValue(), url_specifics.visits(1)); 375 EXPECT_EQ(static_cast<const int>(visits[0].transition), 376 url_specifics.visit_transitions(1)); 377 EXPECT_EQ(visits[1].visit_time.ToInternalValue(), url_specifics.visits(0)); 378 EXPECT_EQ(static_cast<const int>(visits[1].transition), 379 url_specifics.visit_transitions(0)); 380 381 // Check that in-memory representation of sync state is accurate. 382 std::set<GURL> sync_state; 383 typed_url_sync_service_.get()->GetSyncedUrls(&sync_state); 384 EXPECT_FALSE(sync_state.empty()); 385 EXPECT_EQ(1u, sync_state.size()); 386 EXPECT_TRUE(sync_state.end() != sync_state.find(url_row.url())); 387 } 388 389 TEST_F(TypedUrlSyncableServiceTest, LinkVisitLocalTypedUrlAndSync) { 390 syncer::SyncChangeList change_list; 391 392 URLRows url_rows; 393 std::vector<VisitVector> visit_vectors; 394 std::vector<const char*> urls; 395 urls.push_back("http://pie.com/"); 396 397 ASSERT_TRUE( 398 InitiateServerState(1, 0, &url_rows, &visit_vectors, urls, &change_list)); 399 change_list.clear(); 400 401 URLRow url_row = url_rows.front(); 402 VisitVector visits = visit_vectors.front(); 403 404 // Update the URL row, adding a non-typed visit to the visit vector. 405 AddNewestVisit(&url_row, &visits, content::PAGE_TRANSITION_LINK, 6); 406 static_cast<TestHistoryBackend*>(fake_history_backend_.get())-> 407 SetVisitsForUrl(url_row.id(), &visits); 408 409 content::PageTransition transition = content::PAGE_TRANSITION_LINK; 410 // Notify typed url sync service of non-typed visit, expect no change. 411 typed_url_sync_service_->OnUrlVisited(transition, &url_row); 412 ASSERT_EQ(0u, change_list.size()); 413 } 414 415 TEST_F(TypedUrlSyncableServiceTest, TypedVisitLocalTypedUrlAndSync) { 416 syncer::SyncChangeList change_list; 417 418 URLRows url_rows; 419 std::vector<VisitVector> visit_vectors; 420 std::vector<const char*> urls; 421 urls.push_back("http://pie.com/"); 422 423 ASSERT_TRUE( 424 InitiateServerState(1, 0, &url_rows, &visit_vectors, urls, &change_list)); 425 change_list.clear(); 426 427 URLRow url_row = url_rows.front(); 428 VisitVector visits = visit_vectors.front(); 429 430 // Update the URL row, adding another typed visit to the visit vector. 431 AddOldestVisit(&url_row, &visits, content::PAGE_TRANSITION_LINK, 1); 432 AddNewestVisit(&url_row, &visits, content::PAGE_TRANSITION_LINK, 6); 433 AddNewestVisit(&url_row, &visits, content::PAGE_TRANSITION_TYPED, 7); 434 static_cast<TestHistoryBackend*>(fake_history_backend_.get())-> 435 SetVisitsForUrl(url_row.id(), &visits); 436 437 // Notify typed url sync service of typed visit. 438 content::PageTransition transition = content::PAGE_TRANSITION_TYPED; 439 typed_url_sync_service_->OnUrlVisited(transition, &url_row); 440 441 ASSERT_EQ(1u, change_list.size()); 442 ASSERT_TRUE(change_list[0].IsValid()); 443 EXPECT_EQ(syncer::TYPED_URLS, change_list[0].sync_data().GetDataType()); 444 EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, change_list[0].change_type()); 445 446 sync_pb::TypedUrlSpecifics url_specifics = 447 change_list[0].sync_data().GetSpecifics().typed_url(); 448 449 EXPECT_TRUE(URLsEqual(url_row, url_specifics)); 450 ASSERT_EQ(4u, visits.size()); 451 EXPECT_EQ(static_cast<const int>(visits.size()), url_specifics.visits_size()); 452 453 // Check that each visit has been translated/communicated correctly. 454 // Note that the specifics record visits in chronological order, and the 455 // visits from the db are in reverse chronological order. 456 int r = url_specifics.visits_size() - 1; 457 for (int i = 0; i < url_specifics.visits_size(); ++i, --r) { 458 EXPECT_EQ(visits[i].visit_time.ToInternalValue(), url_specifics.visits(r)); 459 EXPECT_EQ(static_cast<const int>(visits[i].transition), 460 url_specifics.visit_transitions(r)); 461 } 462 463 // Check that in-memory representation of sync state is accurate. 464 std::set<GURL> sync_state; 465 typed_url_sync_service_.get()->GetSyncedUrls(&sync_state); 466 EXPECT_FALSE(sync_state.empty()); 467 EXPECT_EQ(1u, sync_state.size()); 468 EXPECT_TRUE(sync_state.end() != sync_state.find(url_row.url())); 469 } 470 471 TEST_F(TypedUrlSyncableServiceTest, DeleteLocalTypedUrlAndSync) { 472 syncer::SyncChangeList change_list; 473 474 URLRows url_rows; 475 std::vector<VisitVector> visit_vectors; 476 std::vector<const char*> urls; 477 urls.push_back("http://pie.com/"); 478 urls.push_back("http://cake.com/"); 479 urls.push_back("http://google.com/"); 480 urls.push_back("http://foo.com/"); 481 urls.push_back("http://bar.com/"); 482 483 ASSERT_TRUE( 484 InitiateServerState(4, 1, &url_rows, &visit_vectors, urls, &change_list)); 485 change_list.clear(); 486 487 // Check that in-memory representation of sync state is accurate. 488 std::set<GURL> sync_state; 489 typed_url_sync_service_.get()->GetSyncedUrls(&sync_state); 490 EXPECT_FALSE(sync_state.empty()); 491 EXPECT_EQ(4u, sync_state.size()); 492 493 // Simulate visit expiry of typed visit, no syncing is done 494 // This is to test that sync relies on the in-memory cache to know 495 // which urls were typed and synced, and should be deleted. 496 url_rows[0].set_typed_count(0); 497 VisitVector visits; 498 static_cast<TestHistoryBackend*>(fake_history_backend_.get())-> 499 SetVisitsForUrl(url_rows[0].id(), &visits); 500 501 // Delete some urls from backend and create deleted row vector. 502 URLRows rows; 503 for (size_t i = 0; i < 3u; ++i) { 504 static_cast<TestHistoryBackend*>(fake_history_backend_.get())-> 505 DeleteVisitsForUrl(url_rows[i].id()); 506 rows.push_back(url_rows[i]); 507 } 508 509 // Notify typed url sync service. 510 typed_url_sync_service_->OnUrlsDeleted(false, false, &rows); 511 512 ASSERT_EQ(3u, change_list.size()); 513 for (size_t i = 0; i < change_list.size(); ++i) { 514 ASSERT_TRUE(change_list[i].IsValid()); 515 ASSERT_EQ(syncer::TYPED_URLS, change_list[i].sync_data().GetDataType()); 516 EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, change_list[i].change_type()); 517 sync_pb::TypedUrlSpecifics url_specifics = 518 change_list[i].sync_data().GetSpecifics().typed_url(); 519 EXPECT_EQ(url_rows[i].url().spec(), url_specifics.url()); 520 } 521 522 // Check that in-memory representation of sync state is accurate. 523 std::set<GURL> sync_state_deleted; 524 typed_url_sync_service_.get()->GetSyncedUrls(&sync_state_deleted); 525 ASSERT_EQ(1u, sync_state_deleted.size()); 526 EXPECT_TRUE(sync_state_deleted.end() != 527 sync_state_deleted.find(url_rows[3].url())); 528 } 529 530 TEST_F(TypedUrlSyncableServiceTest, DeleteAllLocalTypedUrlAndSync) { 531 syncer::SyncChangeList change_list; 532 533 URLRows url_rows; 534 std::vector<VisitVector> visit_vectors; 535 std::vector<const char*> urls; 536 urls.push_back("http://pie.com/"); 537 urls.push_back("http://cake.com/"); 538 urls.push_back("http://google.com/"); 539 urls.push_back("http://foo.com/"); 540 urls.push_back("http://bar.com/"); 541 542 ASSERT_TRUE( 543 InitiateServerState(4, 1, &url_rows, &visit_vectors, urls, &change_list)); 544 change_list.clear(); 545 546 // Check that in-memory representation of sync state is accurate. 547 std::set<GURL> sync_state; 548 typed_url_sync_service_.get()->GetSyncedUrls(&sync_state); 549 EXPECT_EQ(4u, sync_state.size()); 550 551 // Delete urls from backend. 552 for (size_t i = 0; i < 4u; ++ i) { 553 static_cast<TestHistoryBackend*>(fake_history_backend_.get())-> 554 DeleteVisitsForUrl(url_rows[i].id()); 555 } 556 // Delete urls with |all_history| flag set. 557 bool all_history = true; 558 559 // Notify typed url sync service. 560 typed_url_sync_service_->OnUrlsDeleted(all_history, false, NULL); 561 562 ASSERT_EQ(4u, change_list.size()); 563 for (size_t i = 0; i < change_list.size(); ++i) { 564 ASSERT_TRUE(change_list[i].IsValid()); 565 ASSERT_EQ(syncer::TYPED_URLS, change_list[i].sync_data().GetDataType()); 566 EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, change_list[i].change_type()); 567 } 568 // Check that in-memory representation of sync state is accurate. 569 std::set<GURL> sync_state_deleted; 570 typed_url_sync_service_.get()->GetSyncedUrls(&sync_state_deleted); 571 EXPECT_TRUE(sync_state_deleted.empty()); 572 } 573 574 TEST_F(TypedUrlSyncableServiceTest, MaxVisitLocalTypedUrlAndSync) { 575 syncer::SyncChangeList change_list; 576 577 URLRows url_rows; 578 std::vector<VisitVector> visit_vectors; 579 std::vector<const char*> urls; 580 urls.push_back("http://pie.com/"); 581 582 ASSERT_TRUE( 583 InitiateServerState(0, 1, &url_rows, &visit_vectors, urls, &change_list)); 584 585 URLRow url_row = url_rows.front(); 586 VisitVector visits; 587 588 // Add |kMaxTypedUrlVisits| + 10 visits to the url. The 10 oldest 589 // non-typed visits are expected to be skipped. 590 int i = 1; 591 for (; i <= kMaxTypedUrlVisits - 20; ++i) 592 AddNewestVisit(&url_row, &visits, content::PAGE_TRANSITION_TYPED, i); 593 for (; i <= kMaxTypedUrlVisits; ++i) 594 AddNewestVisit(&url_row, &visits, content::PAGE_TRANSITION_LINK, i); 595 for (; i <= kMaxTypedUrlVisits + 10; ++i) 596 AddNewestVisit(&url_row, &visits, content::PAGE_TRANSITION_TYPED, i); 597 598 static_cast<TestHistoryBackend*>(fake_history_backend_.get())-> 599 SetVisitsForUrl(url_row.id(), &visits); 600 601 // Notify typed url sync service of typed visit. 602 content::PageTransition transition = content::PAGE_TRANSITION_TYPED; 603 typed_url_sync_service_->OnUrlVisited(transition, &url_row); 604 605 ASSERT_EQ(1u, change_list.size()); 606 ASSERT_TRUE(change_list[0].IsValid()); 607 sync_pb::TypedUrlSpecifics url_specifics = 608 change_list[0].sync_data().GetSpecifics().typed_url(); 609 ASSERT_EQ(kMaxTypedUrlVisits, url_specifics.visits_size()); 610 611 // Check that each visit has been translated/communicated correctly. 612 // Note that the specifics record visits in chronological order, and the 613 // visits from the db are in reverse chronological order. 614 int num_typed_visits_synced = 0; 615 int num_other_visits_synced = 0; 616 int r = url_specifics.visits_size() - 1; 617 for (int i = 0; i < url_specifics.visits_size(); ++i, --r) { 618 if (url_specifics.visit_transitions(i) == content::PAGE_TRANSITION_TYPED) { 619 ++num_typed_visits_synced; 620 } else { 621 ++num_other_visits_synced; 622 } 623 } 624 EXPECT_EQ(kMaxTypedUrlVisits - 10, num_typed_visits_synced); 625 EXPECT_EQ(10, num_other_visits_synced); 626 } 627 628 TEST_F(TypedUrlSyncableServiceTest, ThrottleVisitLocalTypedUrlSync) { 629 syncer::SyncChangeList change_list; 630 631 URLRows url_rows; 632 std::vector<VisitVector> visit_vectors; 633 std::vector<const char*> urls; 634 urls.push_back("http://pie.com/"); 635 636 ASSERT_TRUE( 637 InitiateServerState(0, 1, &url_rows, &visit_vectors, urls, &change_list)); 638 639 URLRow url_row = url_rows.front(); 640 VisitVector visits; 641 642 // Add enough visits to the url so that typed count is above the throttle 643 // limit, and not right on the interval that gets synced. 644 for (int i = 1; i < 42; ++i) 645 AddNewestVisit(&url_row, &visits, content::PAGE_TRANSITION_TYPED, i); 646 647 static_cast<TestHistoryBackend*>(fake_history_backend_.get())-> 648 SetVisitsForUrl(url_row.id(), &visits); 649 650 // Notify typed url sync service of typed visit. 651 content::PageTransition transition = content::PAGE_TRANSITION_TYPED; 652 typed_url_sync_service_->OnUrlVisited(transition, &url_row); 653 654 // Should throttle, so sync and local cache should not update. 655 ASSERT_EQ(0u, change_list.size()); 656 std::set<GURL> sync_state; 657 typed_url_sync_service_.get()->GetSyncedUrls(&sync_state); 658 EXPECT_TRUE(sync_state.empty()); 659 } 660 661 } // namespace history 662
