chrome/browser/sync/glue/favicon_cache_unittest.cc

   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/sync/glue/favicon_cache.h"
   6
   7 #include "base/message_loop/message_loop.h"
   8 #include "base/strings/string_number_conversions.h"
   9 #include "base/strings/stringprintf.h"
  10 #include "base/time/time.h"
  11 #include "chrome/browser/chrome_notification_types.h"
  12 #include "chrome/browser/history/history_notifications.h"
  13 #include "content/public/browser/notification_service.h"
  14 #include "sync/api/attachments/attachment_id.h"
  15 #include "sync/api/attachments/attachment_service_proxy_for_test.h"
  16 #include "sync/api/sync_change_processor_wrapper_for_test.h"
  17 #include "sync/api/sync_error_factory_mock.h"
  18 #include "sync/api/time.h"
  19 #include "sync/protocol/favicon_image_specifics.pb.h"
  20 #include "sync/protocol/favicon_tracking_specifics.pb.h"
  21 #include "sync/protocol/sync.pb.h"
  22 #include "testing/gtest/include/gtest/gtest.h"
  23
  24 namespace browser_sync {
  25
  26 namespace {
  27
  28 // Total number of favicons to use in sync test batches.
  29 const int kFaviconBatchSize = 10;
  30
  31 // Maximum number of favicons to sync.
  32 const int kMaxSyncFavicons = kFaviconBatchSize*2;
  33
  34 // TestChangeProcessor --------------------------------------------------------
  35
  36 // Dummy SyncChangeProcessor used to help review what SyncChanges are pushed
  37 // back up to Sync.
  38 class TestChangeProcessor : public syncer::SyncChangeProcessor {
  39  public:
  40   TestChangeProcessor();
  41   virtual ~TestChangeProcessor();
  42
  43   // Store a copy of all the changes passed in so we can examine them later.
  44   virtual syncer::SyncError ProcessSyncChanges(
  45       const tracked_objects::Location& from_here,
  46       const syncer::SyncChangeList& change_list) OVERRIDE;
  47
  48   virtual syncer::SyncDataList GetAllSyncData(syncer::ModelType type) const
  49       OVERRIDE {
  50     return syncer::SyncDataList();
  51   }
  52
  53   bool contains_guid(const std::string& guid) const {
  54     return change_map_.count(guid) != 0;
  55   }
  56
  57   syncer::SyncChange change_for_guid(const std::string& guid) const {
  58     DCHECK(contains_guid(guid));
  59     return change_map_.find(guid)->second;
  60   }
  61
  62   // Returns the last change list received, and resets the internal list.
  63   syncer::SyncChangeList GetAndResetChangeList() {
  64     syncer::SyncChangeList list;
  65     list.swap(change_list_);
  66     return list;
  67   }
  68
  69   void set_erroneous(bool erroneous) { erroneous_ = erroneous; }
  70
  71  private:
  72   // Track the changes received in ProcessSyncChanges.
  73   std::map<std::string, syncer::SyncChange> change_map_;
  74   syncer::SyncChangeList change_list_;
  75   bool erroneous_;
  76
  77   DISALLOW_COPY_AND_ASSIGN(TestChangeProcessor);
  78 };
  79
  80 TestChangeProcessor::TestChangeProcessor() : erroneous_(false) {
  81 }
  82
  83 TestChangeProcessor::~TestChangeProcessor() {
  84 }
  85
  86 syncer::SyncError TestChangeProcessor::ProcessSyncChanges(
  87     const tracked_objects::Location& from_here,
  88     const syncer::SyncChangeList& change_list) {
  89   if (erroneous_) {
  90     return syncer::SyncError(
  91         FROM_HERE,
  92         syncer::SyncError::DATATYPE_ERROR,
  93         "Some error.",
  94         change_list[0].sync_data().GetDataType());
  95   }
  96
  97   change_list_.insert(change_list_.end(),
  98                       change_list.begin(),
  99                       change_list.end());
 100   change_map_.erase(change_map_.begin(), change_map_.end());
 101   for (syncer::SyncChangeList::const_iterator iter = change_list.begin();
 102       iter != change_list.end(); ++iter) {
 103     change_map_[iter->sync_data().GetTitle()] = *iter;
 104   }
 105   return syncer::SyncError();
 106 }
 107
 108 // TestFaviconData ------------------------------------------------------------
 109 struct TestFaviconData {
 110   TestFaviconData() : last_visit_time(0), is_bookmarked(false) {}
 111   GURL page_url;
 112   GURL icon_url;
 113   std::string image_16;
 114   std::string image_32;
 115   std::string image_64;
 116   int64 last_visit_time;
 117   bool is_bookmarked;
 118 };
 119
 120 TestFaviconData BuildFaviconData(int index) {
 121   TestFaviconData data;
 122   data.page_url = GURL(base::StringPrintf("http://bla.com/%.2i.html", index));
 123   data.icon_url = GURL(base::StringPrintf("http://bla.com/%.2i.ico", index));
 124   data.image_16 = base::StringPrintf("16 %i", index);
 125   // TODO(zea): enable this once the cache supports writing them.
 126   // data.image_32 = base::StringPrintf("32 %i", index);
 127   // data.image_64 = base::StringPrintf("64 %i", index);
 128   data.last_visit_time = index;
 129   return data;
 130 }
 131
 132 void FillImageSpecifics(
 133     const TestFaviconData& test_data,
 134     sync_pb::FaviconImageSpecifics* image_specifics) {
 135   image_specifics->set_favicon_url(test_data.icon_url.spec());
 136   if (!test_data.image_16.empty()) {
 137     image_specifics->mutable_favicon_web()->set_height(16);
 138     image_specifics->mutable_favicon_web()->set_width(16);
 139     image_specifics->mutable_favicon_web()->set_favicon(test_data.image_16);
 140   }
 141   if (!test_data.image_32.empty()) {
 142     image_specifics->mutable_favicon_web_32()->set_height(32);
 143     image_specifics->mutable_favicon_web_32()->set_width(32);
 144     image_specifics->mutable_favicon_web_32()->set_favicon(test_data.image_32);
 145   }
 146   if (!test_data.image_64.empty()) {
 147     image_specifics->mutable_favicon_touch_64()->set_height(64);
 148     image_specifics->mutable_favicon_touch_64()->set_width(64);
 149     image_specifics->mutable_favicon_touch_64()->
 150         set_favicon(test_data.image_64);
 151   }
 152 }
 153
 154 void FillTrackingSpecifics(
 155     const TestFaviconData& test_data,
 156     sync_pb::FaviconTrackingSpecifics* tracking_specifics) {
 157   tracking_specifics->set_favicon_url(test_data.icon_url.spec());
 158   tracking_specifics->set_last_visit_time_ms(test_data.last_visit_time);
 159   tracking_specifics->set_is_bookmarked(test_data.is_bookmarked);
 160 }
 161
 162 testing::AssertionResult CompareFaviconDataToSpecifics(
 163     const TestFaviconData& test_data,
 164     const sync_pb::EntitySpecifics& specifics) {
 165   if (specifics.has_favicon_image()) {
 166     sync_pb::FaviconImageSpecifics image_specifics = specifics.favicon_image();
 167     if (image_specifics.favicon_url() != test_data.icon_url.spec())
 168       return testing::AssertionFailure() << "Image icon url doesn't match.";
 169     if (!test_data.image_16.empty()) {
 170       if (image_specifics.favicon_web().favicon() != test_data.image_16 ||
 171           image_specifics.favicon_web().height() != 16 ||
 172           image_specifics.favicon_web().width() != 16) {
 173         return testing::AssertionFailure() << "16p image data doesn't match.";
 174       }
 175     } else if (image_specifics.has_favicon_web()) {
 176       return testing::AssertionFailure() << "Missing 16p favicon.";
 177     }
 178     if (!test_data.image_32.empty()) {
 179       if (image_specifics.favicon_web_32().favicon() != test_data.image_32 ||
 180           image_specifics.favicon_web().height() != 32 ||
 181           image_specifics.favicon_web().width() != 32) {
 182         return testing::AssertionFailure() << "32p image data doesn't match.";
 183       }
 184     } else if (image_specifics.has_favicon_web_32()) {
 185       return testing::AssertionFailure() << "Missing 32p favicon.";
 186     }
 187     if (!test_data.image_64.empty()) {
 188       if (image_specifics.favicon_touch_64().favicon() != test_data.image_64 ||
 189           image_specifics.favicon_web().height() != 64 ||
 190           image_specifics.favicon_web().width() != 64) {
 191         return testing::AssertionFailure() << "64p image data doesn't match.";
 192       }
 193     } else if (image_specifics.has_favicon_touch_64()) {
 194       return testing::AssertionFailure() << "Missing 64p favicon.";
 195     }
 196   } else {
 197     sync_pb::FaviconTrackingSpecifics tracking_specifics =
 198         specifics.favicon_tracking();
 199     if (tracking_specifics.favicon_url() != test_data.icon_url.spec())
 200       return testing::AssertionFailure() << "Tracking icon url doesn't match.";
 201     if (tracking_specifics.last_visit_time_ms() != test_data.last_visit_time)
 202       return testing::AssertionFailure() << "Visit time doesn't match.";
 203     if (tracking_specifics.is_bookmarked() != test_data.is_bookmarked)
 204       return testing::AssertionFailure() << "Bookmark status doens't match.";
 205   }
 206   return testing::AssertionSuccess();
 207 }
 208
 209 testing::AssertionResult VerifyChanges(
 210     syncer::ModelType expected_model_type,
 211     const std::vector<syncer::SyncChange::SyncChangeType>&
 212         expected_change_types,
 213     const std::vector<int>& expected_icons,
 214     const syncer::SyncChangeList& change_list) {
 215   DCHECK_EQ(expected_change_types.size(), expected_icons.size());
 216   if (change_list.size() != expected_icons.size())
 217     return testing::AssertionFailure() << "Change list size doesn't match.";
 218   for (size_t i = 0; i < expected_icons.size(); ++i) {
 219     TestFaviconData data = BuildFaviconData(expected_icons[i]);
 220     if (change_list[i].sync_data().GetDataType() != expected_model_type)
 221       return testing::AssertionFailure() << "Change datatype doesn't match.";
 222     if (change_list[i].change_type() != expected_change_types[i])
 223       return testing::AssertionFailure() << "Change type doesn't match.";
 224     if (change_list[i].change_type() == syncer::SyncChange::ACTION_DELETE) {
 225       if (syncer::SyncDataLocal(change_list[i].sync_data()).GetTag() !=
 226           data.icon_url.spec())
 227         return testing::AssertionFailure() << "Deletion url does not match.";
 228     } else {
 229       testing::AssertionResult compare_result =
 230           CompareFaviconDataToSpecifics(
 231               data,
 232               change_list[i].sync_data().GetSpecifics());
 233       if (!compare_result)
 234         return compare_result;
 235     }
 236   }
 237   return testing::AssertionSuccess();
 238 }
 239
 240 // Helper to extract the favicon id embedded in the tag of a sync
 241 // change.
 242 int GetFaviconId(const syncer::SyncChange change) {
 243   std::string tag = syncer::SyncDataLocal(change.sync_data()).GetTag();
 244   const std::string kPrefix = "http://bla.com/";
 245   const std::string kSuffix = ".ico";
 246   if (tag.find(kPrefix) != 0)
 247     return -1;
 248   std::string temp = tag.substr(kPrefix.length());
 249   if (temp.rfind(kSuffix) <= 0)
 250     return -1;
 251   temp = temp.substr(0, temp.rfind(kSuffix));
 252   int result = -1;
 253   if (!base::StringToInt(temp, &result))
 254     return -1;
 255   return result;
 256 }
 257
 258 }  // namespace
 259
 260 class SyncFaviconCacheTest : public testing::Test {
 261  public:
 262   SyncFaviconCacheTest();
 263   virtual ~SyncFaviconCacheTest() {}
 264
 265   void SetUpInitialSync(const syncer::SyncDataList& initial_image_data,
 266                         const syncer::SyncDataList& initial_tracking_data);
 267
 268   size_t GetFaviconCount() const;
 269   size_t GetTaskCount() const;
 270
 271   testing::AssertionResult ExpectFaviconEquals(
 272         const std::string& page_url,
 273         const std::string& bytes) const;
 274   testing::AssertionResult VerifyLocalIcons(
 275       const std::vector<int>& expected_icons);
 276   testing::AssertionResult VerifyLocalCustomIcons(
 277       const std::vector<TestFaviconData>& expected_icons);
 278
 279   scoped_ptr<syncer::SyncChangeProcessor> CreateAndPassProcessor();
 280   scoped_ptr<syncer::SyncErrorFactory> CreateAndPassSyncErrorFactory();
 281
 282   FaviconCache* cache() { return &cache_; }
 283   TestChangeProcessor* processor() { return sync_processor_.get(); }
 284
 285   // Finish an outstanding favicon load for the icon described in |test_data|.
 286   void OnCustomFaviconDataAvailable(const TestFaviconData& test_data);
 287
 288   // Helper method to run the message loop after invoking
 289   // OnReceivedSyncFavicon, which posts an internal task.
 290   void TriggerSyncFaviconReceived(const GURL& page_url,
 291                                   const GURL& icon_url,
 292                                   const std::string& icon_bytes,
 293                                   int64 last_visit_time_ms);
 294
 295  private:
 296   base::MessageLoopForUI message_loop_;
 297   FaviconCache cache_;
 298
 299   // Our dummy ChangeProcessor used to inspect changes pushed to Sync.
 300   scoped_ptr<TestChangeProcessor> sync_processor_;
 301   scoped_ptr<syncer::SyncChangeProcessorWrapperForTest> sync_processor_wrapper_;
 302 };
 303
 304 SyncFaviconCacheTest::SyncFaviconCacheTest()
 305     : cache_(NULL, kMaxSyncFavicons),
 306       sync_processor_(new TestChangeProcessor),
 307       sync_processor_wrapper_(new syncer::SyncChangeProcessorWrapperForTest(
 308           sync_processor_.get())) {}
 309
 310 void SyncFaviconCacheTest::SetUpInitialSync(
 311     const syncer::SyncDataList& initial_image_data,
 312     const syncer::SyncDataList& initial_tracking_data) {
 313   cache()->MergeDataAndStartSyncing(syncer::FAVICON_IMAGES,
 314                                     initial_image_data,
 315                                     CreateAndPassProcessor(),
 316                                     CreateAndPassSyncErrorFactory());
 317   ASSERT_EQ(0U, processor()->GetAndResetChangeList().size());
 318   cache()->MergeDataAndStartSyncing(syncer::FAVICON_TRACKING,
 319                                     initial_tracking_data,
 320                                     CreateAndPassProcessor(),
 321                                     CreateAndPassSyncErrorFactory());
 322   ASSERT_EQ(0U, processor()->GetAndResetChangeList().size());
 323 }
 324
 325 size_t SyncFaviconCacheTest::GetFaviconCount() const {
 326   return cache_.NumFaviconsForTest();
 327 }
 328
 329 size_t SyncFaviconCacheTest::GetTaskCount() const {
 330   return cache_.NumTasksForTest();
 331 }
 332
 333 testing::AssertionResult SyncFaviconCacheTest::ExpectFaviconEquals(
 334     const std::string& page_url,
 335     const std::string& bytes) const {
 336   GURL gurl(page_url);
 337   scoped_refptr<base::RefCountedMemory> favicon;
 338   if (!cache_.GetSyncedFaviconForPageURL(gurl, &favicon))
 339     return testing::AssertionFailure() << "Favicon is missing.";
 340   if (favicon->size() != bytes.size())
 341     return testing::AssertionFailure() << "Favicon sizes don't match.";
 342   for (size_t i = 0; i < favicon->size(); ++i) {
 343     if (bytes[i] != *(favicon->front() + i))
 344       return testing::AssertionFailure() << "Favicon data doesn't match.";
 345   }
 346   return testing::AssertionSuccess();
 347 }
 348
 349 testing::AssertionResult SyncFaviconCacheTest::VerifyLocalIcons(
 350     const std::vector<int>& expected_icons) {
 351   std::vector<TestFaviconData> expected_custom_icons;
 352   for (size_t i = 0; i < expected_icons.size(); ++i) {
 353     expected_custom_icons.push_back(BuildFaviconData(expected_icons[i]));
 354   }
 355   return VerifyLocalCustomIcons(expected_custom_icons);
 356 }
 357
 358
 359 testing::AssertionResult SyncFaviconCacheTest::VerifyLocalCustomIcons(
 360     const std::vector<TestFaviconData>& expected_custom_icons) {
 361   syncer::SyncDataList image_data_list =
 362       cache()->GetAllSyncData(syncer::FAVICON_IMAGES);
 363   syncer::SyncDataList tracking_data_list =
 364       cache()->GetAllSyncData(syncer::FAVICON_TRACKING);
 365   if (expected_custom_icons.size() > image_data_list.size() ||
 366       expected_custom_icons.size() > tracking_data_list.size())
 367     return testing::AssertionFailure() << "Number of icons doesn't match.";
 368   for (size_t i = 0; i < expected_custom_icons.size(); ++i) {
 369     const TestFaviconData& test_data = expected_custom_icons[i];
 370     // Find the test data in the data lists. Assume that both lists have the
 371     // same ordering, which may not match the |expected_custom_icons| ordering.
 372     bool found_match = false;
 373     for (size_t j = 0; j < image_data_list.size(); ++j) {
 374       if (image_data_list[j].GetTitle() != test_data.icon_url.spec())
 375         continue;
 376       found_match = true;
 377       const sync_pb::FaviconImageSpecifics& image_specifics =
 378           image_data_list[j].GetSpecifics().favicon_image();
 379       sync_pb::FaviconImageSpecifics expected_image_specifics;
 380       FillImageSpecifics(test_data, &expected_image_specifics);
 381       if (image_specifics.SerializeAsString() !=
 382           expected_image_specifics.SerializeAsString()) {
 383         return testing::AssertionFailure() << "Image data doesn't match.";
 384       }
 385       const sync_pb::FaviconTrackingSpecifics& tracking_specifics =
 386           tracking_data_list[j].GetSpecifics().favicon_tracking();
 387       sync_pb::FaviconTrackingSpecifics expected_tracking_specifics;
 388       FillTrackingSpecifics(test_data, &expected_tracking_specifics);
 389       if (tracking_specifics.SerializeAsString() !=
 390           expected_tracking_specifics.SerializeAsString()) {
 391         return testing::AssertionFailure() << "Tracking data doesn't match.";
 392       }
 393     }
 394     if (!found_match)
 395       return testing::AssertionFailure() << "Could not find favicon.";
 396   }
 397   return testing::AssertionSuccess();
 398 }
 399
 400 scoped_ptr<syncer::SyncChangeProcessor>
 401 SyncFaviconCacheTest::CreateAndPassProcessor() {
 402   return scoped_ptr<syncer::SyncChangeProcessor>(
 403       new syncer::SyncChangeProcessorWrapperForTest(sync_processor_.get()));
 404 }
 405
 406 scoped_ptr<syncer::SyncErrorFactory> SyncFaviconCacheTest::
 407     CreateAndPassSyncErrorFactory() {
 408   return scoped_ptr<syncer::SyncErrorFactory>(
 409       new syncer::SyncErrorFactoryMock());
 410 }
 411
 412 void SyncFaviconCacheTest::OnCustomFaviconDataAvailable(
 413     const TestFaviconData& test_data) {
 414   std::vector<favicon_base::FaviconBitmapResult> bitmap_results;
 415   if (!test_data.image_16.empty()) {
 416     favicon_base::FaviconBitmapResult bitmap_result;
 417     bitmap_result.icon_url = test_data.icon_url;
 418     bitmap_result.pixel_size.set_width(16);
 419     bitmap_result.pixel_size.set_height(16);
 420     base::RefCountedString* temp_string = new base::RefCountedString();
 421     temp_string->data() = test_data.image_16;
 422     bitmap_result.bitmap_data = temp_string;
 423     bitmap_results.push_back(bitmap_result);
 424   }
 425   if (!test_data.image_32.empty()) {
 426     favicon_base::FaviconBitmapResult bitmap_result;
 427     bitmap_result.icon_url = test_data.icon_url;
 428     bitmap_result.pixel_size.set_width(32);
 429     bitmap_result.pixel_size.set_height(32);
 430     base::RefCountedString* temp_string = new base::RefCountedString();
 431     temp_string->data() = test_data.image_32;
 432     bitmap_result.bitmap_data = temp_string;
 433     bitmap_results.push_back(bitmap_result);
 434   }
 435   if (!test_data.image_64.empty()) {
 436     favicon_base::FaviconBitmapResult bitmap_result;
 437     bitmap_result.icon_url = test_data.icon_url;
 438     bitmap_result.pixel_size.set_width(64);
 439     bitmap_result.pixel_size.set_height(64);
 440     base::RefCountedString* temp_string = new base::RefCountedString();
 441     temp_string->data() = test_data.image_64;
 442     bitmap_result.bitmap_data = temp_string;
 443     bitmap_results.push_back(bitmap_result);
 444   }
 445   cache()->OnFaviconDataAvailable(test_data.page_url, bitmap_results);
 446 }
 447
 448 void SyncFaviconCacheTest::TriggerSyncFaviconReceived(
 449     const GURL& page_url,
 450     const GURL& icon_url,
 451     const std::string& icon_bytes,
 452     int64 last_visit_time_ms) {
 453   cache()->OnReceivedSyncFavicon(page_url,
 454                                  icon_url,
 455                                  icon_bytes,
 456                                  last_visit_time_ms);
 457   message_loop_.RunUntilIdle();
 458 }
 459
 460 // A freshly constructed cache should be empty.
 461 TEST_F(SyncFaviconCacheTest, Empty) {
 462   EXPECT_EQ(0U, GetFaviconCount());
 463 }
 464
 465 TEST_F(SyncFaviconCacheTest, ReceiveSyncFavicon) {
 466   std::string page_url = "http://www.google.com";
 467   std::string fav_url = "http://www.google.com/favicon.ico";
 468   std::string bytes = "bytes";
 469   EXPECT_EQ(0U, GetFaviconCount());
 470   TriggerSyncFaviconReceived(GURL(page_url), GURL(fav_url), bytes, 0);
 471   EXPECT_EQ(1U, GetFaviconCount());
 472   EXPECT_TRUE(ExpectFaviconEquals(page_url, bytes));
 473 }
 474
 475 TEST_F(SyncFaviconCacheTest, ReceiveEmptySyncFavicon) {
 476   std::string page_url = "http://www.google.com";
 477   std::string fav_url = "http://www.google.com/favicon.ico";
 478   std::string bytes = "bytes";
 479   EXPECT_EQ(0U, GetFaviconCount());
 480   TriggerSyncFaviconReceived(GURL(page_url),
 481                              GURL(fav_url),
 482                              std::string(),
 483                              0);
 484   EXPECT_EQ(0U, GetFaviconCount());
 485   EXPECT_FALSE(ExpectFaviconEquals(page_url, std::string()));
 486
 487   // Then receive the actual favicon.
 488   TriggerSyncFaviconReceived(GURL(page_url), GURL(fav_url), bytes, 0);
 489   EXPECT_EQ(1U, GetFaviconCount());
 490   EXPECT_TRUE(ExpectFaviconEquals(page_url, bytes));
 491 }
 492
 493 TEST_F(SyncFaviconCacheTest, ReceiveUpdatedSyncFavicon) {
 494   std::string page_url = "http://www.google.com";
 495   std::string fav_url = "http://www.google.com/favicon.ico";
 496   std::string bytes = "bytes";
 497   std::string bytes2 = "bytes2";
 498   EXPECT_EQ(0U, GetFaviconCount());
 499   TriggerSyncFaviconReceived(GURL(page_url), GURL(fav_url), bytes, 0);
 500   EXPECT_EQ(1U, GetFaviconCount());
 501   EXPECT_TRUE(ExpectFaviconEquals(page_url, bytes));
 502
 503   // The cache should not update existing favicons from tab sync favicons
 504   // (which can be reassociated several times).
 505   TriggerSyncFaviconReceived(GURL(page_url), GURL(fav_url), bytes2, 0);
 506   EXPECT_EQ(1U, GetFaviconCount());
 507   EXPECT_TRUE(ExpectFaviconEquals(page_url, bytes));
 508   EXPECT_FALSE(ExpectFaviconEquals(page_url, bytes2));
 509 }
 510
 511 TEST_F(SyncFaviconCacheTest, MultipleMappings) {
 512   std::string page_url = "http://www.google.com";
 513   std::string page2_url = "http://bla.google.com";
 514   std::string fav_url = "http://www.google.com/favicon.ico";
 515   std::string bytes = "bytes";
 516   EXPECT_EQ(0U, GetFaviconCount());
 517   TriggerSyncFaviconReceived(GURL(page_url), GURL(fav_url), bytes, 0);
 518   EXPECT_EQ(1U, GetFaviconCount());
 519   EXPECT_TRUE(ExpectFaviconEquals(page_url, bytes));
 520
 521   // Map another page to the same favicon. They should share the same data.
 522   TriggerSyncFaviconReceived(GURL(page2_url), GURL(fav_url), bytes, 0);
 523   EXPECT_EQ(1U, GetFaviconCount());
 524   EXPECT_TRUE(ExpectFaviconEquals(page2_url, bytes));
 525 }
 526
 527 TEST_F(SyncFaviconCacheTest, SyncEmpty) {
 528   syncer::SyncMergeResult merge_result =
 529       cache()->MergeDataAndStartSyncing(syncer::FAVICON_IMAGES,
 530                                         syncer::SyncDataList(),
 531                                         CreateAndPassProcessor(),
 532                                         CreateAndPassSyncErrorFactory());
 533
 534   EXPECT_EQ(0U, cache()->GetAllSyncData(syncer::FAVICON_IMAGES).size());
 535   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
 536   EXPECT_EQ(0, merge_result.num_items_added());
 537   EXPECT_EQ(0, merge_result.num_items_modified());
 538   EXPECT_EQ(0, merge_result.num_items_deleted());
 539   EXPECT_EQ(0, merge_result.num_items_before_association());
 540   EXPECT_EQ(0, merge_result.num_items_after_association());
 541
 542   merge_result =
 543       cache()->MergeDataAndStartSyncing(syncer::FAVICON_TRACKING,
 544                                         syncer::SyncDataList(),
 545                                         CreateAndPassProcessor(),
 546                                         CreateAndPassSyncErrorFactory());
 547
 548   EXPECT_EQ(0U, cache()->GetAllSyncData(syncer::FAVICON_TRACKING).size());
 549   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
 550   EXPECT_EQ(0, merge_result.num_items_added());
 551   EXPECT_EQ(0, merge_result.num_items_modified());
 552   EXPECT_EQ(0, merge_result.num_items_deleted());
 553   EXPECT_EQ(0, merge_result.num_items_before_association());
 554   EXPECT_EQ(0, merge_result.num_items_after_association());
 555 }
 556
 557 // Setting up sync with existing local favicons should push those favicons into
 558 // sync.
 559 TEST_F(SyncFaviconCacheTest, SyncExistingLocal) {
 560   std::vector<syncer::SyncChange::SyncChangeType> expected_change_types;
 561   std::vector<int> expected_icons;
 562   for (int i = 0; i < kFaviconBatchSize; ++i) {
 563     TestFaviconData favicon = BuildFaviconData(i);
 564     TriggerSyncFaviconReceived(favicon.page_url,
 565                                favicon.icon_url,
 566                                favicon.image_16,
 567                                i);
 568     expected_change_types.push_back(syncer::SyncChange::ACTION_ADD);
 569     expected_icons.push_back(i);
 570   }
 571
 572   syncer::SyncMergeResult merge_result =
 573       cache()->MergeDataAndStartSyncing(syncer::FAVICON_IMAGES,
 574                                         syncer::SyncDataList(),
 575                                         CreateAndPassProcessor(),
 576                                         CreateAndPassSyncErrorFactory());
 577   EXPECT_EQ((unsigned long)kFaviconBatchSize,
 578             cache()->GetAllSyncData(syncer::FAVICON_IMAGES).size());
 579   syncer::SyncChangeList change_list = processor()->GetAndResetChangeList();
 580   EXPECT_TRUE(VerifyChanges(syncer::FAVICON_IMAGES,
 581                             expected_change_types,
 582                             expected_icons,
 583                             change_list));
 584   EXPECT_EQ(0, merge_result.num_items_added());
 585   EXPECT_EQ(0, merge_result.num_items_modified());
 586   EXPECT_EQ(0, merge_result.num_items_deleted());
 587   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_before_association());
 588   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_after_association());
 589
 590   merge_result =
 591       cache()->MergeDataAndStartSyncing(syncer::FAVICON_TRACKING,
 592                                         syncer::SyncDataList(),
 593                                         CreateAndPassProcessor(),
 594                                         CreateAndPassSyncErrorFactory());
 595   EXPECT_EQ((unsigned long)kFaviconBatchSize,
 596             cache()->GetAllSyncData(syncer::FAVICON_TRACKING).size());
 597   change_list = processor()->GetAndResetChangeList();
 598   EXPECT_TRUE(VerifyChanges(syncer::FAVICON_TRACKING,
 599                             expected_change_types,
 600                             expected_icons,
 601                             change_list));
 602   EXPECT_EQ(0, merge_result.num_items_added());
 603   EXPECT_EQ(0, merge_result.num_items_modified());
 604   EXPECT_EQ(0, merge_result.num_items_deleted());
 605   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_before_association());
 606   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_after_association());
 607 }
 608
 609 // Setting up sync with existing sync data should load that data into the local
 610 // cache.
 611 TEST_F(SyncFaviconCacheTest, SyncExistingRemote) {
 612   syncer::SyncDataList initial_image_data, initial_tracking_data;
 613   std::vector<int> expected_icons;
 614   for (int i = 0; i < kFaviconBatchSize; ++i) {
 615     expected_icons.push_back(i);
 616     sync_pb::EntitySpecifics image_specifics, tracking_specifics;
 617     FillImageSpecifics(BuildFaviconData(i),
 618                        image_specifics.mutable_favicon_image());
 619     initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
 620         1,
 621         image_specifics,
 622         base::Time(),
 623         syncer::AttachmentIdList(),
 624         syncer::AttachmentServiceProxyForTest::Create()));
 625     FillTrackingSpecifics(BuildFaviconData(i),
 626                           tracking_specifics.mutable_favicon_tracking());
 627     initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
 628         1,
 629         tracking_specifics,
 630         base::Time(),
 631         syncer::AttachmentIdList(),
 632         syncer::AttachmentServiceProxyForTest::Create()));
 633   }
 634
 635   syncer::SyncMergeResult merge_result =
 636       cache()->MergeDataAndStartSyncing(syncer::FAVICON_IMAGES,
 637                                         initial_image_data,
 638                                         CreateAndPassProcessor(),
 639                                         CreateAndPassSyncErrorFactory());
 640   EXPECT_EQ((unsigned long)kFaviconBatchSize,
 641             cache()->GetAllSyncData(syncer::FAVICON_IMAGES).size());
 642   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
 643   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_added());
 644   EXPECT_EQ(0, merge_result.num_items_modified());
 645   EXPECT_EQ(0, merge_result.num_items_deleted());
 646   EXPECT_EQ(0, merge_result.num_items_before_association());
 647   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_after_association());
 648
 649   merge_result =
 650       cache()->MergeDataAndStartSyncing(syncer::FAVICON_TRACKING,
 651                                         initial_tracking_data,
 652                                         CreateAndPassProcessor(),
 653                                         CreateAndPassSyncErrorFactory());
 654   EXPECT_EQ((unsigned long)kFaviconBatchSize,
 655             cache()->GetAllSyncData(syncer::FAVICON_TRACKING).size());
 656   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
 657   EXPECT_EQ(0, merge_result.num_items_added());
 658   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_modified());
 659   EXPECT_EQ(0, merge_result.num_items_deleted());
 660   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_before_association());
 661   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_after_association());
 662
 663   ASSERT_TRUE(VerifyLocalIcons(expected_icons));
 664 }
 665
 666 // Setting up sync with local data and sync data should merge the two image
 667 // sets, with remote data having priority in case both exist.
 668 TEST_F(SyncFaviconCacheTest, SyncMergesImages) {
 669   // First go through and add local 16p favicons.
 670   for (int i = 0; i < kFaviconBatchSize; ++i) {
 671     TestFaviconData favicon = BuildFaviconData(i);
 672     TriggerSyncFaviconReceived(favicon.page_url,
 673                                favicon.icon_url,
 674                                favicon.image_16,
 675                                i);
 676   }
 677
 678   // Then go through and create the initial sync data, which does not have 16p
 679   // favicons for the first half, and has custom 16p favicons for the second.
 680   std::vector<syncer::SyncChange::SyncChangeType> expected_change_types;
 681   std::vector<int> expected_icons;
 682   std::vector<TestFaviconData> expected_data;
 683   syncer::SyncDataList initial_image_data, initial_tracking_data;
 684   for (int i = 0; i < kFaviconBatchSize; ++i) {
 685     sync_pb::EntitySpecifics image_specifics, tracking_specifics;
 686     TestFaviconData test_data = BuildFaviconData(i);
 687     if (i < kFaviconBatchSize/2) {
 688       test_data.image_16 = std::string();
 689       expected_icons.push_back(i);
 690       expected_change_types.push_back(syncer::SyncChange::ACTION_UPDATE);
 691     } else {
 692       test_data.image_16 += "custom";
 693       expected_data.push_back(test_data);
 694     }
 695     FillImageSpecifics(test_data,
 696                        image_specifics.mutable_favicon_image());
 697
 698     initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
 699         1,
 700         image_specifics,
 701         base::Time(),
 702         syncer::AttachmentIdList(),
 703         syncer::AttachmentServiceProxyForTest::Create()));
 704     FillTrackingSpecifics(test_data,
 705                           tracking_specifics.mutable_favicon_tracking());
 706     initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
 707         1,
 708         tracking_specifics,
 709         base::Time(),
 710         syncer::AttachmentIdList(),
 711         syncer::AttachmentServiceProxyForTest::Create()));
 712   }
 713
 714   syncer::SyncMergeResult merge_result =
 715       cache()->MergeDataAndStartSyncing(syncer::FAVICON_IMAGES,
 716                                         initial_image_data,
 717                                         CreateAndPassProcessor(),
 718                                         CreateAndPassSyncErrorFactory());
 719   EXPECT_EQ((unsigned long)kFaviconBatchSize,
 720             cache()->GetAllSyncData(syncer::FAVICON_IMAGES).size());
 721   syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
 722   EXPECT_EQ((unsigned long)kFaviconBatchSize/2, changes.size());
 723   EXPECT_EQ(0, merge_result.num_items_added());
 724   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_modified());
 725   EXPECT_EQ(0, merge_result.num_items_deleted());
 726   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_before_association());
 727   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_after_association());
 728
 729   merge_result =
 730       cache()->MergeDataAndStartSyncing(syncer::FAVICON_TRACKING,
 731                                         initial_tracking_data,
 732                                         CreateAndPassProcessor(),
 733                                         CreateAndPassSyncErrorFactory());
 734   EXPECT_EQ((unsigned long)kFaviconBatchSize,
 735             cache()->GetAllSyncData(syncer::FAVICON_TRACKING).size());
 736   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
 737   EXPECT_EQ(0, merge_result.num_items_added());
 738   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_modified());
 739   EXPECT_EQ(0, merge_result.num_items_deleted());
 740   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_before_association());
 741   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_after_association());
 742
 743   ASSERT_TRUE(VerifyLocalIcons(expected_icons));
 744   ASSERT_TRUE(VerifyLocalCustomIcons(expected_data));
 745   ASSERT_TRUE(VerifyChanges(syncer::FAVICON_IMAGES,
 746                             expected_change_types,
 747                             expected_icons,
 748                             changes));
 749 }
 750
 751 // Setting up sync with local data and sync data should merge the two tracking
 752 // sets, such that the visit time is the most recent.
 753 TEST_F(SyncFaviconCacheTest, SyncMergesTracking) {
 754   // First go through and add local 16p favicons.
 755   for (int i = 0; i < kFaviconBatchSize; ++i) {
 756     TestFaviconData favicon = BuildFaviconData(i);
 757     TriggerSyncFaviconReceived(favicon.page_url,
 758                                favicon.icon_url,
 759                                favicon.image_16,
 760                                i);
 761   }
 762
 763   // Then go through and create the initial sync data, which for the first half
 764   // the local has a newer visit, and for the second the remote does.
 765   std::vector<syncer::SyncChange::SyncChangeType> expected_change_types;
 766   std::vector<int> expected_icons;
 767   std::vector<TestFaviconData> expected_data;
 768   syncer::SyncDataList initial_image_data, initial_tracking_data;
 769   for (int i = 0; i < kFaviconBatchSize; ++i) {
 770     sync_pb::EntitySpecifics image_specifics, tracking_specifics;
 771     TestFaviconData test_data = BuildFaviconData(i);
 772     if (i < kFaviconBatchSize/2) {
 773       test_data.last_visit_time = i-1;
 774       expected_icons.push_back(i);
 775       expected_change_types.push_back(syncer::SyncChange::ACTION_UPDATE);
 776     } else {
 777       test_data.last_visit_time = i+1;
 778       expected_data.push_back(test_data);
 779     }
 780     FillImageSpecifics(test_data,
 781                        image_specifics.mutable_favicon_image());
 782
 783     initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
 784         1,
 785         image_specifics,
 786         base::Time(),
 787         syncer::AttachmentIdList(),
 788         syncer::AttachmentServiceProxyForTest::Create()));
 789     FillTrackingSpecifics(test_data,
 790                           tracking_specifics.mutable_favicon_tracking());
 791     initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
 792         1,
 793         tracking_specifics,
 794         base::Time(),
 795         syncer::AttachmentIdList(),
 796         syncer::AttachmentServiceProxyForTest::Create()));
 797   }
 798
 799   syncer::SyncMergeResult merge_result =
 800       cache()->MergeDataAndStartSyncing(syncer::FAVICON_IMAGES,
 801                                         initial_image_data,
 802                                         CreateAndPassProcessor(),
 803                                         CreateAndPassSyncErrorFactory());
 804   EXPECT_EQ((unsigned long)kFaviconBatchSize,
 805             cache()->GetAllSyncData(syncer::FAVICON_IMAGES).size());
 806   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
 807   EXPECT_EQ(0, merge_result.num_items_added());
 808   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_modified());
 809   EXPECT_EQ(0, merge_result.num_items_deleted());
 810   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_before_association());
 811   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_after_association());
 812
 813   merge_result =
 814       cache()->MergeDataAndStartSyncing(syncer::FAVICON_TRACKING,
 815                                         initial_tracking_data,
 816                                         CreateAndPassProcessor(),
 817                                         CreateAndPassSyncErrorFactory());
 818   EXPECT_EQ((unsigned long)kFaviconBatchSize,
 819             cache()->GetAllSyncData(syncer::FAVICON_TRACKING).size());
 820   syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
 821   EXPECT_EQ((unsigned long)kFaviconBatchSize/2, changes.size());
 822   EXPECT_EQ(0, merge_result.num_items_added());
 823   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_modified());
 824   EXPECT_EQ(0, merge_result.num_items_deleted());
 825   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_before_association());
 826   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_after_association());
 827
 828   ASSERT_TRUE(VerifyLocalIcons(expected_icons));
 829   ASSERT_TRUE(VerifyLocalCustomIcons(expected_data));
 830   ASSERT_TRUE(VerifyChanges(syncer::FAVICON_TRACKING,
 831                             expected_change_types,
 832                             expected_icons,
 833                             changes));
 834 }
 835
 836 // Receiving old icons (missing image data) should result in pushing the new
 837 // merged icons back to the remote syncer.
 838 TEST_F(SyncFaviconCacheTest, ReceiveStaleImages) {
 839   syncer::SyncDataList initial_image_data, initial_tracking_data;
 840   syncer::SyncChangeList stale_changes;
 841   std::vector<int> expected_icons;
 842   std::vector<syncer::SyncChange::SyncChangeType> expected_change_types;
 843   for (int i = 0; i < kFaviconBatchSize; ++i) {
 844     expected_icons.push_back(i);
 845     sync_pb::EntitySpecifics image_specifics, tracking_specifics;
 846     FillImageSpecifics(BuildFaviconData(i),
 847                        image_specifics.mutable_favicon_image());
 848     initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
 849         1,
 850         image_specifics,
 851         base::Time(),
 852         syncer::AttachmentIdList(),
 853         syncer::AttachmentServiceProxyForTest::Create()));
 854     expected_change_types.push_back(syncer::SyncChange::ACTION_UPDATE);
 855     image_specifics.mutable_favicon_image()->clear_favicon_web();
 856     stale_changes.push_back(syncer::SyncChange(
 857         FROM_HERE,
 858         syncer::SyncChange::ACTION_UPDATE,
 859         syncer::SyncData::CreateRemoteData(
 860             1,
 861             image_specifics,
 862             base::Time(),
 863             syncer::AttachmentIdList(),
 864             syncer::AttachmentServiceProxyForTest::Create())));
 865     FillTrackingSpecifics(BuildFaviconData(i),
 866                           tracking_specifics.mutable_favicon_tracking());
 867     initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
 868         1,
 869         tracking_specifics,
 870         base::Time(),
 871         syncer::AttachmentIdList(),
 872         syncer::AttachmentServiceProxyForTest::Create()));
 873   }
 874
 875   SetUpInitialSync(initial_image_data, initial_tracking_data);
 876
 877   // Now receive the same icons as an update, but with missing image data.
 878   cache()->ProcessSyncChanges(FROM_HERE, stale_changes);
 879   syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
 880   ASSERT_TRUE(VerifyLocalIcons(expected_icons));
 881   ASSERT_EQ((unsigned long)kFaviconBatchSize, changes.size());
 882   ASSERT_TRUE(VerifyChanges(syncer::FAVICON_IMAGES,
 883                             expected_change_types,
 884                             expected_icons,
 885                             changes));
 886 }
 887
 888 // New icons should be added locally without pushing anything back to the
 889 // remote syncer.
 890 TEST_F(SyncFaviconCacheTest, ReceiveNewImages) {
 891   syncer::SyncDataList initial_image_data, initial_tracking_data;
 892   syncer::SyncChangeList new_changes;
 893   std::vector<int> expected_icons;
 894   for (int i = 0; i < kFaviconBatchSize; ++i) {
 895     expected_icons.push_back(i);
 896     TestFaviconData test_data = BuildFaviconData(i);
 897     sync_pb::EntitySpecifics image_specifics, tracking_specifics;
 898     FillImageSpecifics(test_data,
 899                        image_specifics.mutable_favicon_image());
 900     new_changes.push_back(syncer::SyncChange(
 901         FROM_HERE,
 902         syncer::SyncChange::ACTION_UPDATE,
 903         syncer::SyncData::CreateRemoteData(
 904             1,
 905             image_specifics,
 906             base::Time(),
 907             syncer::AttachmentIdList(),
 908             syncer::AttachmentServiceProxyForTest::Create())));
 909     image_specifics.mutable_favicon_image()
 910         ->mutable_favicon_web()
 911         ->mutable_favicon()
 912         ->append("old");
 913     initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
 914         1,
 915         image_specifics,
 916         base::Time(),
 917         syncer::AttachmentIdList(),
 918         syncer::AttachmentServiceProxyForTest::Create()));
 919     FillTrackingSpecifics(BuildFaviconData(i),
 920                           tracking_specifics.mutable_favicon_tracking());
 921     initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
 922         1,
 923         tracking_specifics,
 924         base::Time(),
 925         syncer::AttachmentIdList(),
 926         syncer::AttachmentServiceProxyForTest::Create()));
 927   }
 928
 929   SetUpInitialSync(initial_image_data, initial_tracking_data);
 930
 931   // Now receive the new icons as an update.
 932   cache()->ProcessSyncChanges(FROM_HERE, new_changes);
 933   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
 934   ASSERT_TRUE(VerifyLocalIcons(expected_icons));
 935 }
 936
 937 // Recieving the same icons as the local data should have no effect.
 938 TEST_F(SyncFaviconCacheTest, ReceiveSameImages) {
 939   syncer::SyncDataList initial_image_data, initial_tracking_data;
 940   syncer::SyncChangeList same_changes;
 941   std::vector<int> expected_icons;
 942   for (int i = 0; i < kFaviconBatchSize; ++i) {
 943     expected_icons.push_back(i);
 944     TestFaviconData test_data = BuildFaviconData(i);
 945     sync_pb::EntitySpecifics image_specifics, tracking_specifics;
 946     FillImageSpecifics(test_data,
 947                        image_specifics.mutable_favicon_image());
 948     same_changes.push_back(syncer::SyncChange(
 949         FROM_HERE,
 950         syncer::SyncChange::ACTION_UPDATE,
 951         syncer::SyncData::CreateRemoteData(
 952             1,
 953             image_specifics,
 954             base::Time(),
 955             syncer::AttachmentIdList(),
 956             syncer::AttachmentServiceProxyForTest::Create())));
 957     initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
 958         1,
 959         image_specifics,
 960         base::Time(),
 961         syncer::AttachmentIdList(),
 962         syncer::AttachmentServiceProxyForTest::Create()));
 963     FillTrackingSpecifics(BuildFaviconData(i),
 964                           tracking_specifics.mutable_favicon_tracking());
 965     initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
 966         1,
 967         tracking_specifics,
 968         base::Time(),
 969         syncer::AttachmentIdList(),
 970         syncer::AttachmentServiceProxyForTest::Create()));
 971   }
 972
 973   SetUpInitialSync(initial_image_data, initial_tracking_data);
 974
 975   // Now receive the new icons as an update.
 976   cache()->ProcessSyncChanges(FROM_HERE, same_changes);
 977   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
 978   ASSERT_TRUE(VerifyLocalIcons(expected_icons));
 979 }
 980
 981 // Receiving stale tracking (old visit times) should result in pushing back
 982 // the newer visit times to the remote syncer.
 983 TEST_F(SyncFaviconCacheTest, ReceiveStaleTracking) {
 984   syncer::SyncDataList initial_image_data, initial_tracking_data;
 985   syncer::SyncChangeList stale_changes;
 986   std::vector<int> expected_icons;
 987   std::vector<syncer::SyncChange::SyncChangeType> expected_change_types;
 988   for (int i = 0; i < kFaviconBatchSize; ++i) {
 989     expected_icons.push_back(i);
 990     sync_pb::EntitySpecifics image_specifics, tracking_specifics;
 991     FillImageSpecifics(BuildFaviconData(i),
 992                        image_specifics.mutable_favicon_image());
 993     initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
 994         1,
 995         image_specifics,
 996         base::Time(),
 997         syncer::AttachmentIdList(),
 998         syncer::AttachmentServiceProxyForTest::Create()));
 999     expected_change_types.push_back(syncer::SyncChange::ACTION_UPDATE);
1000     FillTrackingSpecifics(BuildFaviconData(i),
1001                           tracking_specifics.mutable_favicon_tracking());
1002     initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
1003         1,
1004         tracking_specifics,
1005         base::Time(),
1006         syncer::AttachmentIdList(),
1007         syncer::AttachmentServiceProxyForTest::Create()));
1008     tracking_specifics.mutable_favicon_tracking()->set_last_visit_time_ms(-1);
1009     stale_changes.push_back(syncer::SyncChange(
1010         FROM_HERE,
1011         syncer::SyncChange::ACTION_UPDATE,
1012         syncer::SyncData::CreateRemoteData(
1013             1,
1014             tracking_specifics,
1015             base::Time(),
1016             syncer::AttachmentIdList(),
1017             syncer::AttachmentServiceProxyForTest::Create())));
1018   }
1019
1020   SetUpInitialSync(initial_image_data, initial_tracking_data);
1021
1022   // Now receive the same icons as an update, but with missing image data.
1023   cache()->ProcessSyncChanges(FROM_HERE, stale_changes);
1024   syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
1025   ASSERT_TRUE(VerifyLocalIcons(expected_icons));
1026   ASSERT_EQ((unsigned long)kFaviconBatchSize, changes.size());
1027   ASSERT_TRUE(VerifyChanges(syncer::FAVICON_TRACKING,
1028                             expected_change_types,
1029                             expected_icons,
1030                             changes));
1031 }
1032
1033 // New tracking information should be added locally without pushing anything
1034 // back to the remote syncer.
1035 TEST_F(SyncFaviconCacheTest, ReceiveNewTracking) {
1036   syncer::SyncDataList initial_image_data, initial_tracking_data;
1037   syncer::SyncChangeList new_changes;
1038   std::vector<int> expected_icons;
1039   // We start from one here so that we don't have to deal with a -1 visit time.
1040   for (int i = 1; i <= kFaviconBatchSize; ++i) {
1041     expected_icons.push_back(i);
1042     sync_pb::EntitySpecifics image_specifics, tracking_specifics;
1043     FillImageSpecifics(BuildFaviconData(i),
1044                        image_specifics.mutable_favicon_image());
1045     initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
1046         1,
1047         image_specifics,
1048         base::Time(),
1049         syncer::AttachmentIdList(),
1050         syncer::AttachmentServiceProxyForTest::Create()));
1051     FillTrackingSpecifics(BuildFaviconData(i),
1052                           tracking_specifics.mutable_favicon_tracking());
1053     new_changes.push_back(syncer::SyncChange(
1054         FROM_HERE,
1055         syncer::SyncChange::ACTION_UPDATE,
1056         syncer::SyncData::CreateRemoteData(
1057             1,
1058             tracking_specifics,
1059             base::Time(),
1060             syncer::AttachmentIdList(),
1061             syncer::AttachmentServiceProxyForTest::Create())));
1062     tracking_specifics.mutable_favicon_tracking()->set_last_visit_time_ms(i-1);
1063     initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
1064         1,
1065         tracking_specifics,
1066         base::Time(),
1067         syncer::AttachmentIdList(),
1068         syncer::AttachmentServiceProxyForTest::Create()));
1069   }
1070
1071   SetUpInitialSync(initial_image_data, initial_tracking_data);
1072
1073   // Now receive the new icons as an update.
1074   cache()->ProcessSyncChanges(FROM_HERE, new_changes);
1075   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
1076   ASSERT_TRUE(VerifyLocalIcons(expected_icons));
1077 }
1078
1079 // Receiving the same tracking information as the local data should have no
1080 // effect.
1081 TEST_F(SyncFaviconCacheTest, ReceiveSameTracking) {
1082   syncer::SyncDataList initial_image_data, initial_tracking_data;
1083   syncer::SyncChangeList same_changes;
1084   std::vector<int> expected_icons;
1085   for (int i = 0; i < kFaviconBatchSize; ++i) {
1086     expected_icons.push_back(i);
1087     sync_pb::EntitySpecifics image_specifics, tracking_specifics;
1088     FillImageSpecifics(BuildFaviconData(i),
1089                        image_specifics.mutable_favicon_image());
1090     initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
1091         1,
1092         image_specifics,
1093         base::Time(),
1094         syncer::AttachmentIdList(),
1095         syncer::AttachmentServiceProxyForTest::Create()));
1096     FillTrackingSpecifics(BuildFaviconData(i),
1097                           tracking_specifics.mutable_favicon_tracking());
1098     initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
1099         1,
1100         tracking_specifics,
1101         base::Time(),
1102         syncer::AttachmentIdList(),
1103         syncer::AttachmentServiceProxyForTest::Create()));
1104     same_changes.push_back(syncer::SyncChange(
1105         FROM_HERE,
1106         syncer::SyncChange::ACTION_UPDATE,
1107         syncer::SyncData::CreateRemoteData(
1108             1,
1109             tracking_specifics,
1110             base::Time(),
1111             syncer::AttachmentIdList(),
1112             syncer::AttachmentServiceProxyForTest::Create())));
1113   }
1114
1115   SetUpInitialSync(initial_image_data, initial_tracking_data);
1116
1117   // Now receive the new icons as an update.
1118   cache()->ProcessSyncChanges(FROM_HERE, same_changes);
1119   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
1120   ASSERT_TRUE(VerifyLocalIcons(expected_icons));
1121 }
1122
1123 // Verify we can delete favicons after setting up sync.
1124 TEST_F(SyncFaviconCacheTest, DeleteFavicons) {
1125   syncer::SyncDataList initial_image_data, initial_tracking_data;
1126   syncer::SyncChangeList tracking_deletions, image_deletions;
1127   for (int i = 0; i < kFaviconBatchSize; ++i) {
1128     sync_pb::EntitySpecifics image_specifics, tracking_specifics;
1129     FillImageSpecifics(BuildFaviconData(i),
1130                        image_specifics.mutable_favicon_image());
1131     initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
1132         1,
1133         image_specifics,
1134         base::Time(),
1135         syncer::AttachmentIdList(),
1136         syncer::AttachmentServiceProxyForTest::Create()));
1137     FillTrackingSpecifics(BuildFaviconData(i),
1138                           tracking_specifics.mutable_favicon_tracking());
1139     initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
1140         1,
1141         tracking_specifics,
1142         base::Time(),
1143         syncer::AttachmentIdList(),
1144         syncer::AttachmentServiceProxyForTest::Create()));
1145     tracking_deletions.push_back(syncer::SyncChange(
1146         FROM_HERE,
1147         syncer::SyncChange::ACTION_DELETE,
1148         syncer::SyncData::CreateRemoteData(
1149             1,
1150             tracking_specifics,
1151             base::Time(),
1152             syncer::AttachmentIdList(),
1153             syncer::AttachmentServiceProxyForTest::Create())));
1154     image_deletions.push_back(syncer::SyncChange(
1155         FROM_HERE,
1156         syncer::SyncChange::ACTION_DELETE,
1157         syncer::SyncData::CreateRemoteData(
1158             1,
1159             image_specifics,
1160             base::Time(),
1161             syncer::AttachmentIdList(),
1162             syncer::AttachmentServiceProxyForTest::Create())));
1163   }
1164
1165   SetUpInitialSync(initial_image_data, initial_tracking_data);
1166
1167   // Now receive the tracking deletions. Since we'll still have orphan data,
1168   // the favicon count should remain the same.
1169   EXPECT_EQ((unsigned long)kFaviconBatchSize, GetFaviconCount());
1170   cache()->ProcessSyncChanges(FROM_HERE, tracking_deletions);
1171   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
1172   EXPECT_EQ((unsigned long)kFaviconBatchSize, GetFaviconCount());
1173
1174   // Once the image deletions arrive, the favicon count should be 0 again.
1175   cache()->ProcessSyncChanges(FROM_HERE, image_deletions);
1176   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
1177   EXPECT_EQ(0U, GetFaviconCount());
1178 }
1179
1180 // Ensure that MergeDataAndStartSyncing enforces the sync favicon limit by
1181 // dropping local icons.
1182 TEST_F(SyncFaviconCacheTest, ExpireOnMergeData) {
1183   std::vector<int> expected_icons;
1184   syncer::SyncDataList initial_image_data, initial_tracking_data;
1185
1186   // Set up sync so it has the maximum number of favicons, while the local has
1187   // the same amount of different favicons.
1188   for (int i = 0; i < kMaxSyncFavicons; ++i) {
1189     sync_pb::EntitySpecifics image_specifics, tracking_specifics;
1190     FillImageSpecifics(BuildFaviconData(i),
1191                        image_specifics.mutable_favicon_image());
1192     initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
1193         1,
1194         image_specifics,
1195         base::Time(),
1196         syncer::AttachmentIdList(),
1197         syncer::AttachmentServiceProxyForTest::Create()));
1198     FillTrackingSpecifics(BuildFaviconData(i),
1199                           tracking_specifics.mutable_favicon_tracking());
1200     initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
1201         1,
1202         tracking_specifics,
1203         base::Time(),
1204         syncer::AttachmentIdList(),
1205         syncer::AttachmentServiceProxyForTest::Create()));
1206     expected_icons.push_back(i);
1207
1208     TestFaviconData favicon = BuildFaviconData(i+kMaxSyncFavicons);
1209     TriggerSyncFaviconReceived(favicon.page_url,
1210                                favicon.icon_url,
1211                                favicon.image_16,
1212                                i+kMaxSyncFavicons);
1213   }
1214
1215   EXPECT_FALSE(VerifyLocalIcons(expected_icons));
1216
1217   // Drops image part of the unsynced icons.
1218   syncer::SyncMergeResult merge_result =
1219       cache()->MergeDataAndStartSyncing(syncer::FAVICON_IMAGES,
1220                                         initial_image_data,
1221                                         CreateAndPassProcessor(),
1222                                         CreateAndPassSyncErrorFactory());
1223   EXPECT_EQ((unsigned long)kMaxSyncFavicons * 2,
1224             GetFaviconCount());  // Still have tracking.
1225   EXPECT_EQ((unsigned long)kMaxSyncFavicons,
1226             cache()->GetAllSyncData(syncer::FAVICON_IMAGES).size());
1227   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
1228   EXPECT_EQ(kMaxSyncFavicons, merge_result.num_items_added());
1229   EXPECT_EQ(0, merge_result.num_items_modified());
1230   EXPECT_EQ(kMaxSyncFavicons, merge_result.num_items_deleted());
1231   EXPECT_EQ(kMaxSyncFavicons, merge_result.num_items_before_association());
1232   EXPECT_EQ(kMaxSyncFavicons * 2, merge_result.num_items_after_association());
1233
1234   // Drops tracking part of the unsynced icons.
1235   merge_result =
1236       cache()->MergeDataAndStartSyncing(syncer::FAVICON_TRACKING,
1237                                         initial_tracking_data,
1238                                         CreateAndPassProcessor(),
1239                                         CreateAndPassSyncErrorFactory());
1240   EXPECT_EQ((unsigned long)kMaxSyncFavicons,
1241             cache()->GetAllSyncData(syncer::FAVICON_TRACKING).size());
1242   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
1243   EXPECT_EQ(0, merge_result.num_items_added());
1244   EXPECT_EQ(kMaxSyncFavicons, merge_result.num_items_modified());
1245   EXPECT_EQ(kMaxSyncFavicons, merge_result.num_items_deleted());
1246   EXPECT_EQ(kMaxSyncFavicons * 2, merge_result.num_items_before_association());
1247   EXPECT_EQ(kMaxSyncFavicons, merge_result.num_items_after_association());
1248
1249   EXPECT_TRUE(VerifyLocalIcons(expected_icons));
1250 }
1251
1252 // Receiving sync additions (via ProcessSyncChanges) should not trigger
1253 // expirations.
1254 TEST_F(SyncFaviconCacheTest, NoExpireOnProcessSyncChanges) {
1255   syncer::SyncDataList initial_image_data, initial_tracking_data;
1256   syncer::SyncChangeList image_changes, tracking_changes;
1257   std::vector<int> expected_icons;
1258   for (int i = 0; i < kMaxSyncFavicons; ++i) {
1259     expected_icons.push_back(i);
1260     sync_pb::EntitySpecifics image_specifics, tracking_specifics;
1261     FillImageSpecifics(BuildFaviconData(i),
1262                        image_specifics.mutable_favicon_image());
1263     initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
1264         1,
1265         image_specifics,
1266         base::Time(),
1267         syncer::AttachmentIdList(),
1268         syncer::AttachmentServiceProxyForTest::Create()));
1269     FillTrackingSpecifics(BuildFaviconData(i),
1270                           tracking_specifics.mutable_favicon_tracking());
1271     initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
1272         1,
1273         tracking_specifics,
1274         base::Time(),
1275         syncer::AttachmentIdList(),
1276         syncer::AttachmentServiceProxyForTest::Create()));
1277     // Set up new tracking specifics for the icons received at change time.
1278     expected_icons.push_back(i + kMaxSyncFavicons);
1279     FillImageSpecifics(BuildFaviconData(i + kMaxSyncFavicons),
1280                        image_specifics.mutable_favicon_image());
1281     image_changes.push_back(syncer::SyncChange(
1282         FROM_HERE,
1283         syncer::SyncChange::ACTION_ADD,
1284         syncer::SyncData::CreateRemoteData(
1285             1,
1286             image_specifics,
1287             base::Time(),
1288             syncer::AttachmentIdList(),
1289             syncer::AttachmentServiceProxyForTest::Create())));
1290     FillTrackingSpecifics(BuildFaviconData(i + kMaxSyncFavicons),
1291                           tracking_specifics.mutable_favicon_tracking());
1292     tracking_changes.push_back(syncer::SyncChange(
1293         FROM_HERE,
1294         syncer::SyncChange::ACTION_ADD,
1295         syncer::SyncData::CreateRemoteData(
1296             1,
1297             tracking_specifics,
1298             base::Time(),
1299             syncer::AttachmentIdList(),
1300             syncer::AttachmentServiceProxyForTest::Create())));
1301   }
1302
1303   SetUpInitialSync(initial_image_data, initial_tracking_data);
1304
1305   // Now receive the new icons as an update.
1306   EXPECT_EQ((unsigned long)kMaxSyncFavicons, GetFaviconCount());
1307   cache()->ProcessSyncChanges(FROM_HERE, image_changes);
1308   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
1309   cache()->ProcessSyncChanges(FROM_HERE, tracking_changes);
1310   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
1311   EXPECT_TRUE(VerifyLocalIcons(expected_icons));
1312   EXPECT_GT(GetFaviconCount(), (unsigned long)kMaxSyncFavicons);
1313 }
1314
1315 // Test that visiting a new page triggers a favicon load and a sync addition.
1316 TEST_F(SyncFaviconCacheTest, AddOnFaviconVisited) {
1317   EXPECT_EQ(0U, GetFaviconCount());
1318   SetUpInitialSync(syncer::SyncDataList(), syncer::SyncDataList());
1319   std::vector<int> expected_icons;
1320
1321   for (int i = 0; i < kFaviconBatchSize; ++i) {
1322     expected_icons.push_back(i);
1323     TestFaviconData test_data = BuildFaviconData(i);
1324     cache()->OnFaviconVisited(test_data.page_url, test_data.icon_url);
1325   }
1326
1327   EXPECT_EQ((unsigned long)kFaviconBatchSize, GetTaskCount());
1328
1329   for (int i = 0; i < kFaviconBatchSize; ++i) {
1330     TestFaviconData test_data = BuildFaviconData(i);
1331     OnCustomFaviconDataAvailable(test_data);
1332
1333     syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
1334     ASSERT_EQ(2U, changes.size());
1335     EXPECT_EQ(syncer::SyncChange::ACTION_ADD, changes[0].change_type());
1336     EXPECT_EQ(syncer::FAVICON_IMAGES, changes[0].sync_data().GetDataType());
1337     EXPECT_TRUE(
1338         CompareFaviconDataToSpecifics(test_data,
1339                                       changes[0].sync_data().GetSpecifics()));
1340     EXPECT_EQ(syncer::FAVICON_TRACKING, changes[1].sync_data().GetDataType());
1341     // Just verify the favicon url for the tracking specifics and that the
1342     // timestamp is non-null.
1343     EXPECT_EQ(syncer::SyncChange::ACTION_ADD, changes[1].change_type());
1344     EXPECT_EQ(test_data.icon_url.spec(),
1345               changes[1].sync_data().GetSpecifics().favicon_tracking().
1346                   favicon_url());
1347     EXPECT_NE(changes[1].sync_data().GetSpecifics().favicon_tracking().
1348                   last_visit_time_ms(), 0);
1349   }
1350
1351   EXPECT_EQ(0U, GetTaskCount());
1352   EXPECT_EQ((unsigned long)kFaviconBatchSize, GetFaviconCount());
1353 }
1354
1355 // Test that visiting a known page does not trigger a favicon load and just
1356 // updates the sync tracking info.
1357 TEST_F(SyncFaviconCacheTest, UpdateOnFaviconVisited) {
1358   EXPECT_EQ(0U, GetFaviconCount());
1359   SetUpInitialSync(syncer::SyncDataList(), syncer::SyncDataList());
1360   std::vector<int> expected_icons;
1361
1362   // Add the favicons.
1363   for (int i = 0; i < kFaviconBatchSize; ++i) {
1364     expected_icons.push_back(i);
1365     TestFaviconData test_data = BuildFaviconData(i);
1366     cache()->OnFaviconVisited(test_data.page_url, test_data.icon_url);
1367     OnCustomFaviconDataAvailable(test_data);
1368   }
1369   syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
1370
1371   // Visit the favicons again.
1372   EXPECT_EQ(0U, GetTaskCount());
1373   for (int i = 0; i < kFaviconBatchSize; ++i) {
1374     TestFaviconData test_data = BuildFaviconData(i);
1375     cache()->OnFaviconVisited(test_data.page_url, test_data.icon_url);
1376
1377     syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
1378     ASSERT_EQ(1U, changes.size());
1379     // Just verify the favicon url for the tracking specifics and that the
1380     // timestamp is non-null.
1381     EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, changes[0].change_type());
1382     EXPECT_EQ(test_data.icon_url.spec(),
1383               changes[0].sync_data().GetSpecifics().favicon_tracking().
1384                   favicon_url());
1385     EXPECT_NE(changes[0].sync_data().GetSpecifics().favicon_tracking().
1386                   last_visit_time_ms(), 0);
1387   }
1388   EXPECT_EQ(0U, GetTaskCount());
1389   EXPECT_EQ((unsigned long)kFaviconBatchSize, GetFaviconCount());
1390 }
1391
1392 // Ensure we properly expire old synced favicons as new ones are updated.
1393 TEST_F(SyncFaviconCacheTest, ExpireOnFaviconVisited) {
1394   EXPECT_EQ(0U, GetFaviconCount());
1395   SetUpInitialSync(syncer::SyncDataList(), syncer::SyncDataList());
1396   std::vector<int> expected_icons;
1397
1398   // Add the initial favicons.
1399   for (int i = 0; i < kMaxSyncFavicons; ++i) {
1400     expected_icons.push_back(i);
1401     TestFaviconData test_data = BuildFaviconData(i);
1402     cache()->OnFaviconVisited(test_data.page_url, test_data.icon_url);
1403     OnCustomFaviconDataAvailable(test_data);
1404   }
1405   syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
1406
1407   // Visit some new favicons, triggering expirations of the old favicons.
1408   EXPECT_EQ(0U, GetTaskCount());
1409   for (int i = 0; i < kFaviconBatchSize; ++i) {
1410     TestFaviconData old_favicon = BuildFaviconData(i);
1411     TestFaviconData test_data = BuildFaviconData(i + kMaxSyncFavicons);
1412     cache()->OnFaviconVisited(test_data.page_url, test_data.icon_url);
1413     OnCustomFaviconDataAvailable(test_data);
1414
1415     syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
1416     ASSERT_EQ(4U, changes.size());
1417     EXPECT_EQ(syncer::SyncChange::ACTION_ADD, changes[0].change_type());
1418     EXPECT_TRUE(
1419         CompareFaviconDataToSpecifics(test_data,
1420                                       changes[0].sync_data().GetSpecifics()));
1421     EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, changes[1].change_type());
1422     EXPECT_EQ(old_favicon.icon_url.spec(),
1423               syncer::SyncDataLocal(changes[1].sync_data()).GetTag());
1424
1425     EXPECT_EQ(syncer::SyncChange::ACTION_ADD, changes[2].change_type());
1426     EXPECT_EQ(test_data.icon_url.spec(),
1427               changes[2].sync_data().GetSpecifics().favicon_tracking().
1428                   favicon_url());
1429     EXPECT_NE(changes[2].sync_data().GetSpecifics().favicon_tracking().
1430                   last_visit_time_ms(), 0);
1431     EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, changes[3].change_type());
1432     EXPECT_EQ(old_favicon.icon_url.spec(),
1433               syncer::SyncDataLocal(changes[3].sync_data()).GetTag());
1434   }
1435
1436   EXPECT_EQ(0U, GetTaskCount());
1437   EXPECT_EQ((unsigned long)kMaxSyncFavicons, GetFaviconCount());
1438 }
1439
1440 // A full history clear notification should result in all synced favicons being
1441 // deleted.
1442 TEST_F(SyncFaviconCacheTest, HistoryFullClear) {
1443   syncer::SyncDataList initial_image_data, initial_tracking_data;
1444   std::vector<int> expected_icons;
1445   std::vector<syncer::SyncChange::SyncChangeType> expected_deletions;
1446   for (int i = 0; i < kFaviconBatchSize; ++i) {
1447     expected_icons.push_back(i);
1448     expected_deletions.push_back(syncer::SyncChange::ACTION_DELETE);
1449     TestFaviconData test_data = BuildFaviconData(i);
1450     sync_pb::EntitySpecifics image_specifics, tracking_specifics;
1451     FillImageSpecifics(test_data,
1452                        image_specifics.mutable_favicon_image());
1453     initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
1454         1,
1455         image_specifics,
1456         base::Time(),
1457         syncer::AttachmentIdList(),
1458         syncer::AttachmentServiceProxyForTest::Create()));
1459     FillTrackingSpecifics(BuildFaviconData(i),
1460                           tracking_specifics.mutable_favicon_tracking());
1461     initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
1462         1,
1463         tracking_specifics,
1464         base::Time(),
1465         syncer::AttachmentIdList(),
1466         syncer::AttachmentServiceProxyForTest::Create()));
1467   }
1468
1469   SetUpInitialSync(initial_image_data, initial_tracking_data);
1470   syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
1471   EXPECT_TRUE(changes.empty());
1472
1473   history::URLsDeletedDetails deletions;
1474   deletions.all_history = true;
1475   EXPECT_EQ((unsigned long)kFaviconBatchSize, GetFaviconCount());
1476   content::NotificationService::current()->Notify(
1477         chrome::NOTIFICATION_HISTORY_URLS_DELETED,
1478         content::Source<Profile>(NULL),
1479         content::Details<history::URLsDeletedDetails>(&deletions));
1480   EXPECT_EQ(0U, GetFaviconCount());
1481   changes = processor()->GetAndResetChangeList();
1482   ASSERT_EQ(changes.size(), (unsigned long)kFaviconBatchSize*2);
1483   syncer::SyncChangeList changes_1, changes_2;
1484   for (int i = 0; i < kFaviconBatchSize; ++i) {
1485     changes_1.push_back(changes[i]);
1486     changes_2.push_back(changes[i + kFaviconBatchSize]);
1487   }
1488   VerifyChanges(syncer::FAVICON_IMAGES,
1489                 expected_deletions,
1490                 expected_icons,
1491                 changes_1);
1492   VerifyChanges(syncer::FAVICON_TRACKING,
1493                 expected_deletions,
1494                 expected_icons,
1495                 changes_2);
1496 }
1497
1498 // A partial history clear notification should result in the expired favicons
1499 // also being deleted from sync.
1500 TEST_F(SyncFaviconCacheTest, HistorySubsetClear) {
1501   syncer::SyncDataList initial_image_data, initial_tracking_data;
1502   std::vector<int> expected_icons;
1503   std::vector<syncer::SyncChange::SyncChangeType> expected_deletions;
1504   history::URLsDeletedDetails deletions;
1505   for (int i = 0; i < kFaviconBatchSize; ++i) {
1506     TestFaviconData test_data = BuildFaviconData(i);
1507     if (i < kFaviconBatchSize/2) {
1508       expected_icons.push_back(i);
1509       expected_deletions.push_back(syncer::SyncChange::ACTION_DELETE);
1510       deletions.favicon_urls.insert(test_data.icon_url);
1511     }
1512     sync_pb::EntitySpecifics image_specifics, tracking_specifics;
1513     FillImageSpecifics(test_data,
1514                        image_specifics.mutable_favicon_image());
1515     initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
1516         1,
1517         image_specifics,
1518         base::Time(),
1519         syncer::AttachmentIdList(),
1520         syncer::AttachmentServiceProxyForTest::Create()));
1521     FillTrackingSpecifics(BuildFaviconData(i),
1522                           tracking_specifics.mutable_favicon_tracking());
1523     initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
1524         1,
1525         tracking_specifics,
1526         base::Time(),
1527         syncer::AttachmentIdList(),
1528         syncer::AttachmentServiceProxyForTest::Create()));
1529   }
1530
1531   SetUpInitialSync(initial_image_data, initial_tracking_data);
1532   syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
1533   EXPECT_TRUE(changes.empty());
1534
1535   EXPECT_EQ((unsigned long)kFaviconBatchSize, GetFaviconCount());
1536   content::NotificationService::current()->Notify(
1537         chrome::NOTIFICATION_HISTORY_URLS_DELETED,
1538         content::Source<Profile>(NULL),
1539         content::Details<history::URLsDeletedDetails>(&deletions));
1540   EXPECT_EQ((unsigned long)kFaviconBatchSize/2, GetFaviconCount());
1541   changes = processor()->GetAndResetChangeList();
1542   ASSERT_EQ(changes.size(), (unsigned long)kFaviconBatchSize);
1543   syncer::SyncChangeList changes_1, changes_2;
1544   for (size_t i = 0; i < kFaviconBatchSize/2; ++i) {
1545     changes_1.push_back(changes[i]);
1546     changes_2.push_back(changes[i + kFaviconBatchSize/2]);
1547   }
1548   VerifyChanges(syncer::FAVICON_IMAGES,
1549                 expected_deletions,
1550                 expected_icons,
1551                 changes_1);
1552   VerifyChanges(syncer::FAVICON_TRACKING,
1553                 expected_deletions,
1554                 expected_icons,
1555                 changes_2);
1556 }
1557
1558 // Any favicon urls with the "data" scheme should be ignored.
1559 TEST_F(SyncFaviconCacheTest, IgnoreDataScheme) {
1560   EXPECT_EQ(0U, GetFaviconCount());
1561   SetUpInitialSync(syncer::SyncDataList(), syncer::SyncDataList());
1562   std::vector<int> expected_icons;
1563
1564   for (int i = 0; i < kFaviconBatchSize; ++i) {
1565     TestFaviconData test_data = BuildFaviconData(i);
1566     cache()->OnFaviconVisited(test_data.page_url, GURL());
1567   }
1568
1569   EXPECT_EQ((unsigned long)kFaviconBatchSize, GetTaskCount());
1570
1571   for (int i = 0; i < kFaviconBatchSize; ++i) {
1572     TestFaviconData test_data = BuildFaviconData(i);
1573     test_data.icon_url = GURL("data:image/png;base64;blabla");
1574     EXPECT_TRUE(test_data.icon_url.is_valid());
1575     OnCustomFaviconDataAvailable(test_data);
1576   }
1577
1578   EXPECT_EQ(0U, GetTaskCount());
1579   EXPECT_EQ(0U, GetFaviconCount());
1580   syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
1581   EXPECT_TRUE(changes.empty());
1582 }
1583
1584 // When visiting a page we've already loaded the favicon for, don't attempt to
1585 // reload the favicon, just update the visit time using the cached icon url.
1586 TEST_F(SyncFaviconCacheTest, ReuseCachedIconUrl) {
1587   EXPECT_EQ(0U, GetFaviconCount());
1588   SetUpInitialSync(syncer::SyncDataList(), syncer::SyncDataList());
1589   std::vector<int> expected_icons;
1590
1591   for (int i = 0; i < kFaviconBatchSize; ++i) {
1592     expected_icons.push_back(i);
1593     TestFaviconData test_data = BuildFaviconData(i);
1594     cache()->OnFaviconVisited(test_data.page_url, test_data.icon_url);
1595   }
1596
1597   EXPECT_EQ((unsigned long)kFaviconBatchSize, GetTaskCount());
1598
1599   for (int i = 0; i < kFaviconBatchSize; ++i) {
1600     TestFaviconData test_data = BuildFaviconData(i);
1601     OnCustomFaviconDataAvailable(test_data);
1602   }
1603   processor()->GetAndResetChangeList();
1604   EXPECT_EQ(0U, GetTaskCount());
1605   EXPECT_EQ((unsigned long)kFaviconBatchSize, GetFaviconCount());
1606
1607   for (int i = 0; i < kFaviconBatchSize; ++i) {
1608     TestFaviconData test_data = BuildFaviconData(i);
1609     cache()->OnFaviconVisited(test_data.page_url, test_data.icon_url);
1610     syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
1611     ASSERT_EQ(1U, changes.size());
1612     // Just verify the favicon url for the tracking specifics and that the
1613     // timestamp is non-null.
1614     EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, changes[0].change_type());
1615     EXPECT_EQ(test_data.icon_url.spec(),
1616               changes[0].sync_data().GetSpecifics().favicon_tracking().
1617                   favicon_url());
1618     EXPECT_NE(changes[0].sync_data().GetSpecifics().favicon_tracking().
1619                   last_visit_time_ms(), 0);
1620   }
1621   EXPECT_EQ(0U, GetTaskCount());
1622 }
1623
1624 // If we wind up with orphan image/tracking nodes, then receive an update
1625 // for those favicons, we should lazily create the missing nodes.
1626 TEST_F(SyncFaviconCacheTest, UpdatedOrphans) {
1627   EXPECT_EQ(0U, GetFaviconCount());
1628   SetUpInitialSync(syncer::SyncDataList(), syncer::SyncDataList());
1629
1630   syncer::SyncChangeList initial_image_changes;
1631   syncer::SyncChangeList initial_tracking_changes;
1632   for (int i = 0; i < kFaviconBatchSize; ++i) {
1633     TestFaviconData test_data = BuildFaviconData(i);
1634     // Even favicons have image data but no tracking data. Odd favicons have
1635     // tracking data but no image data.
1636     if (i % 2 == 0) {
1637       sync_pb::EntitySpecifics image_specifics;
1638       FillImageSpecifics(BuildFaviconData(i),
1639                          image_specifics.mutable_favicon_image());
1640       initial_image_changes.push_back(syncer::SyncChange(
1641           FROM_HERE,
1642           syncer::SyncChange::ACTION_ADD,
1643           syncer::SyncData::CreateRemoteData(
1644               1,
1645               image_specifics,
1646               base::Time(),
1647               syncer::AttachmentIdList(),
1648               syncer::AttachmentServiceProxyForTest::Create())));
1649     } else {
1650       sync_pb::EntitySpecifics tracking_specifics;
1651       FillTrackingSpecifics(BuildFaviconData(i),
1652                             tracking_specifics.mutable_favicon_tracking());
1653       initial_tracking_changes.push_back(syncer::SyncChange(
1654           FROM_HERE,
1655           syncer::SyncChange::ACTION_ADD,
1656           syncer::SyncData::CreateRemoteData(
1657               1,
1658               tracking_specifics,
1659               base::Time(),
1660               syncer::AttachmentIdList(),
1661               syncer::AttachmentServiceProxyForTest::Create())));
1662     }
1663   }
1664
1665   cache()->ProcessSyncChanges(FROM_HERE, initial_image_changes);
1666   cache()->ProcessSyncChanges(FROM_HERE, initial_tracking_changes);
1667   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
1668   EXPECT_EQ((unsigned long)kFaviconBatchSize, GetFaviconCount());
1669
1670   for (int i = 0; i < kFaviconBatchSize/2; ++i) {
1671     TestFaviconData test_data = BuildFaviconData(i);
1672     cache()->OnFaviconVisited(test_data.page_url, GURL());
1673     EXPECT_EQ(1U, GetTaskCount());
1674     OnCustomFaviconDataAvailable(test_data);
1675     syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
1676
1677     // Even favicons had image data, so should now receive new tracking data
1678     // and updated image data (we allow one update after the initial add).
1679     // Odd favicons had tracking so should now receive new image data and
1680     // updated tracking data.
1681     if (i % 2 == 0) {
1682       ASSERT_EQ(2U, changes.size());
1683       EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, changes[0].change_type());
1684       EXPECT_TRUE(
1685           CompareFaviconDataToSpecifics(test_data,
1686                                         changes[0].sync_data().GetSpecifics()));
1687       EXPECT_EQ(syncer::SyncChange::ACTION_ADD, changes[1].change_type());
1688       EXPECT_EQ(test_data.icon_url.spec(),
1689                 changes[1].sync_data().GetSpecifics().favicon_tracking().
1690                     favicon_url());
1691       EXPECT_NE(changes[1].sync_data().GetSpecifics().favicon_tracking().
1692                     last_visit_time_ms(), 0);
1693     } else {
1694       ASSERT_EQ(2U, changes.size());
1695       EXPECT_EQ(syncer::SyncChange::ACTION_ADD, changes[0].change_type());
1696       EXPECT_TRUE(
1697           CompareFaviconDataToSpecifics(test_data,
1698                                         changes[0].sync_data().GetSpecifics()));
1699       EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, changes[1].change_type());
1700       EXPECT_EQ(test_data.icon_url.spec(),
1701                 changes[1].sync_data().GetSpecifics().favicon_tracking().
1702                     favicon_url());
1703       EXPECT_NE(changes[1].sync_data().GetSpecifics().favicon_tracking().
1704                     last_visit_time_ms(), 0);
1705     }
1706   }
1707
1708   EXPECT_EQ(0U, GetTaskCount());
1709   EXPECT_EQ((unsigned long)kFaviconBatchSize, GetFaviconCount());
1710 }
1711
1712 // Verify that orphaned favicon images don't result in creating invalid
1713 // favicon tracking data.
1714 TEST_F(SyncFaviconCacheTest, PartialAssociationInfo) {
1715   syncer::SyncDataList initial_image_data, initial_tracking_data;
1716   for (int i = 0; i < kFaviconBatchSize; ++i) {
1717     sync_pb::EntitySpecifics image_specifics;
1718     FillImageSpecifics(BuildFaviconData(i),
1719                        image_specifics.mutable_favicon_image());
1720     initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
1721         1,
1722         image_specifics,
1723         base::Time(),
1724         syncer::AttachmentIdList(),
1725         syncer::AttachmentServiceProxyForTest::Create()));
1726     image_specifics.mutable_favicon_image()->clear_favicon_web();
1727   }
1728
1729   SetUpInitialSync(initial_image_data, initial_tracking_data);
1730   syncer::SyncChangeList change_list = processor()->GetAndResetChangeList();
1731   EXPECT_TRUE(change_list.empty());
1732   EXPECT_EQ((unsigned long)kFaviconBatchSize, GetFaviconCount());
1733 }
1734
1735 // Tests that we don't choke if a favicon visit node with a null visit time is
1736 // present (see crbug.com/258196) and an update is made.
1737 TEST_F(SyncFaviconCacheTest, NullFaviconVisitTime) {
1738   EXPECT_EQ(0U, GetFaviconCount());
1739
1740   syncer::SyncDataList initial_image_data, initial_tracking_data;
1741   std::vector<int> expected_icons;
1742   for (int i = 0; i < kFaviconBatchSize; ++i) {
1743     expected_icons.push_back(i);
1744     sync_pb::EntitySpecifics image_specifics, tracking_specifics;
1745     FillImageSpecifics(BuildFaviconData(i),
1746                        image_specifics.mutable_favicon_image());
1747     initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
1748         1,
1749         image_specifics,
1750         base::Time(),
1751         syncer::AttachmentIdList(),
1752         syncer::AttachmentServiceProxyForTest::Create()));
1753     FillTrackingSpecifics(BuildFaviconData(i),
1754                           tracking_specifics.mutable_favicon_tracking());
1755     tracking_specifics.mutable_favicon_tracking()->set_last_visit_time_ms(
1756         syncer::TimeToProtoTime(base::Time()));
1757     initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
1758         1,
1759         tracking_specifics,
1760         base::Time(),
1761         syncer::AttachmentIdList(),
1762         syncer::AttachmentServiceProxyForTest::Create()));
1763   }
1764
1765   cache()->MergeDataAndStartSyncing(syncer::FAVICON_IMAGES,
1766                                     initial_image_data,
1767                                     CreateAndPassProcessor(),
1768                                     CreateAndPassSyncErrorFactory());
1769   ASSERT_EQ(0U, processor()->GetAndResetChangeList().size());
1770   cache()->MergeDataAndStartSyncing(syncer::FAVICON_TRACKING,
1771                                     initial_tracking_data,
1772                                     CreateAndPassProcessor(),
1773                                     CreateAndPassSyncErrorFactory());
1774   ASSERT_EQ((unsigned long)kFaviconBatchSize,
1775             processor()->GetAndResetChangeList().size());
1776   EXPECT_EQ((unsigned long)kFaviconBatchSize, GetFaviconCount());
1777
1778   // Visit the favicons again.
1779   EXPECT_EQ(0U, GetTaskCount());
1780   for (int i = 0; i < kFaviconBatchSize; ++i) {
1781     TestFaviconData test_data = BuildFaviconData(i);
1782     cache()->OnFaviconVisited(test_data.page_url, test_data.icon_url);
1783
1784     syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
1785     ASSERT_EQ(1U, changes.size());
1786     // Just verify the favicon url for the tracking specifics and that the
1787     // timestamp is non-null.
1788     EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, changes[0].change_type());
1789     EXPECT_EQ(test_data.icon_url.spec(),
1790               changes[0].sync_data().GetSpecifics().favicon_tracking().
1791                   favicon_url());
1792     EXPECT_NE(changes[0].sync_data().GetSpecifics().favicon_tracking().
1793                   last_visit_time_ms(), 0);
1794   }
1795   EXPECT_EQ(0U, GetTaskCount());
1796   EXPECT_EQ((unsigned long)kFaviconBatchSize, GetFaviconCount());
1797 }
1798
1799 // If another synced client has a clock skewed towards the future, it's possible
1800 // that favicons added locally will be expired as they are added. Ensure this
1801 // doesn't crash (see crbug.com/306150).
1802 TEST_F(SyncFaviconCacheTest, VisitFaviconClockSkew) {
1803   EXPECT_EQ(0U, GetFaviconCount());
1804   const int kClockSkew = 20;  // 20 minutes in the future.
1805
1806   // Set up sync with kMaxSyncFavicons starting kClockSkew minutes in the
1807   // future.
1808   syncer::SyncDataList initial_image_data, initial_tracking_data;
1809   for (int i = 0; i < kMaxSyncFavicons; ++i) {
1810     sync_pb::EntitySpecifics image_specifics, tracking_specifics;
1811     TestFaviconData test_data = BuildFaviconData(i);
1812     test_data.last_visit_time =
1813         syncer::TimeToProtoTime(
1814             base::Time::Now() + base::TimeDelta::FromMinutes(kClockSkew));
1815     FillImageSpecifics(test_data,
1816                        image_specifics.mutable_favicon_image());
1817     initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
1818         1,
1819         image_specifics,
1820         base::Time(),
1821         syncer::AttachmentIdList(),
1822         syncer::AttachmentServiceProxyForTest::Create()));
1823     FillTrackingSpecifics(test_data,
1824                           tracking_specifics.mutable_favicon_tracking());
1825     initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
1826         1,
1827         tracking_specifics,
1828         base::Time(),
1829         syncer::AttachmentIdList(),
1830         syncer::AttachmentServiceProxyForTest::Create()));
1831   }
1832   SetUpInitialSync(initial_image_data, initial_tracking_data);
1833
1834   // Visit some new favicons with local time, which will be expired as they
1835   // are added.
1836   EXPECT_EQ(0U, GetTaskCount());
1837   for (int i = 0; i < kClockSkew; ++i) {
1838     TestFaviconData test_data = BuildFaviconData(i + kMaxSyncFavicons);
1839     cache()->OnFaviconVisited(test_data.page_url, test_data.icon_url);
1840     OnCustomFaviconDataAvailable(test_data);
1841
1842     // The changes will be an add followed by a delete for both the image and
1843     // tracking info.
1844     syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
1845     ASSERT_EQ(changes.size(), 4U);
1846     ASSERT_EQ(changes[0].change_type(), syncer::SyncChange::ACTION_ADD);
1847     ASSERT_EQ(changes[0].sync_data().GetDataType(), syncer::FAVICON_IMAGES);
1848     ASSERT_EQ(changes[1].change_type(), syncer::SyncChange::ACTION_DELETE);
1849     ASSERT_EQ(changes[1].sync_data().GetDataType(), syncer::FAVICON_IMAGES);
1850     ASSERT_EQ(changes[2].change_type(), syncer::SyncChange::ACTION_ADD);
1851     ASSERT_EQ(changes[2].sync_data().GetDataType(), syncer::FAVICON_TRACKING);
1852     ASSERT_EQ(changes[3].change_type(), syncer::SyncChange::ACTION_DELETE);
1853     ASSERT_EQ(changes[3].sync_data().GetDataType(), syncer::FAVICON_TRACKING);
1854   }
1855   EXPECT_EQ(0U, GetTaskCount());
1856   EXPECT_EQ((unsigned long)kMaxSyncFavicons, GetFaviconCount());
1857 }
1858
1859 // Simulate a case where the set of tracking info and image info doesn't match,
1860 // and there is more tracking info than the max. A local update should correctly
1861 // determine whether to update/add an image/tracking entity.
1862 TEST_F(SyncFaviconCacheTest, MixedThreshold) {
1863   // First go through and add local favicons.
1864   for (int i = kMaxSyncFavicons; i < kMaxSyncFavicons + 5; ++i) {
1865     TestFaviconData favicon = BuildFaviconData(i);
1866     TriggerSyncFaviconReceived(favicon.page_url,
1867                                favicon.icon_url,
1868                                favicon.image_16,
1869                                favicon.last_visit_time);
1870   }
1871
1872   syncer::SyncDataList initial_image_data, initial_tracking_data;
1873   // Then sync with enough favicons such that the tracking info is over the max
1874   // after merge completes.
1875   for (int i = 0; i < kMaxSyncFavicons; ++i) {
1876     sync_pb::EntitySpecifics image_specifics;
1877     // Push the images forward by 5, to match the unsynced favicons.
1878     FillImageSpecifics(BuildFaviconData(i + 5),
1879                        image_specifics.mutable_favicon_image());
1880     initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
1881         1,
1882         image_specifics,
1883         base::Time(),
1884         syncer::AttachmentIdList(),
1885         syncer::AttachmentServiceProxyForTest::Create()));
1886
1887     sync_pb::EntitySpecifics tracking_specifics;
1888     FillTrackingSpecifics(BuildFaviconData(i),
1889                           tracking_specifics.mutable_favicon_tracking());
1890     initial_tracking_data.push_back(syncer::SyncData::CreateRemoteData(
1891         1,
1892         tracking_specifics,
1893         base::Time(),
1894         syncer::AttachmentIdList(),
1895         syncer::AttachmentServiceProxyForTest::Create()));
1896   }
1897   SetUpInitialSync(initial_image_data, initial_tracking_data);
1898
1899   // The local unsynced tracking info should be dropped, but not deleted.
1900   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
1901
1902   // Because the image and tracking data don't overlap, the total number of
1903   // favicons is still over the limit.
1904   EXPECT_EQ((unsigned long)kMaxSyncFavicons + 5, GetFaviconCount());
1905
1906   // Trigger a tracking change for one of the favicons whose tracking info
1907   // was dropped, resulting in a tracking add and expiration of the orphaned
1908   // images.
1909   TestFaviconData test_data = BuildFaviconData(kMaxSyncFavicons);
1910   cache()->OnFaviconVisited(test_data.page_url, test_data.icon_url);
1911
1912   syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
1913   // 1 image update, 5 image deletions, 1 tracking deletion.
1914   ASSERT_EQ(6U, changes.size());
1915   // Expire image for favicon[kMaxSyncFavicons + 1].
1916   EXPECT_EQ(changes[0].change_type(), syncer::SyncChange::ACTION_DELETE);
1917   EXPECT_EQ(changes[0].sync_data().GetDataType(), syncer::FAVICON_IMAGES);
1918   EXPECT_EQ(kMaxSyncFavicons + 1, GetFaviconId(changes[0]));
1919   // Expire image for favicon[kMaxSyncFavicons + 2].
1920   EXPECT_EQ(changes[1].change_type(), syncer::SyncChange::ACTION_DELETE);
1921   EXPECT_EQ(changes[1].sync_data().GetDataType(), syncer::FAVICON_IMAGES);
1922   EXPECT_EQ(kMaxSyncFavicons + 2, GetFaviconId(changes[1]));
1923   // Expire image for favicon[kMaxSyncFavicons + 3].
1924   EXPECT_EQ(changes[2].change_type(), syncer::SyncChange::ACTION_DELETE);
1925   EXPECT_EQ(changes[2].sync_data().GetDataType(), syncer::FAVICON_IMAGES);
1926   EXPECT_EQ(kMaxSyncFavicons + 3, GetFaviconId(changes[2]));
1927   // Expire image for favicon[kMaxSyncFavicons + 4].
1928   EXPECT_EQ(changes[3].change_type(), syncer::SyncChange::ACTION_DELETE);
1929   EXPECT_EQ(changes[3].sync_data().GetDataType(), syncer::FAVICON_IMAGES);
1930   EXPECT_EQ(kMaxSyncFavicons + 4, GetFaviconId(changes[3]));
1931   // Update tracking for favicon[kMaxSyncFavicons].
1932   EXPECT_EQ(changes[4].change_type(), syncer::SyncChange::ACTION_ADD);
1933   EXPECT_EQ(changes[4].sync_data().GetDataType(), syncer::FAVICON_TRACKING);
1934   EXPECT_EQ(kMaxSyncFavicons, GetFaviconId(changes[4]));
1935   // Expire tracking for favicon[0].
1936   EXPECT_EQ(changes[5].change_type(), syncer::SyncChange::ACTION_DELETE);
1937   EXPECT_EQ(changes[5].sync_data().GetDataType(), syncer::FAVICON_TRACKING);
1938   EXPECT_EQ(0, GetFaviconId(changes[5]));
1939 }
1940
1941 }  // namespace browser_sync