[Sync] Fixing sync_driver lint violations and adding PRESUBMIT lint check.

components/sync_driver/favicon_cache_unittest.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/sync_driver/favicon_cache.h"
 
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
@@ skipping 552 matching lines @@
                                i);
     expected_change_types.push_back(syncer::SyncChange::ACTION_ADD);
     expected_icons.push_back(i);
   }
 
   syncer::SyncMergeResult merge_result =
       cache()->MergeDataAndStartSyncing(syncer::FAVICON_IMAGES,
                                         syncer::SyncDataList(),
                                         CreateAndPassProcessor(),
                                         CreateAndPassSyncErrorFactory());
-  EXPECT_EQ((unsigned long)kFaviconBatchSize,
+  EXPECT_EQ(static_cast<size_t>(kFaviconBatchSize),
             cache()->GetAllSyncData(syncer::FAVICON_IMAGES).size());
   syncer::SyncChangeList change_list = processor()->GetAndResetChangeList();
   EXPECT_TRUE(VerifyChanges(syncer::FAVICON_IMAGES,
                             expected_change_types,
                             expected_icons,
                             change_list));
   EXPECT_EQ(0, merge_result.num_items_added());
   EXPECT_EQ(0, merge_result.num_items_modified());
   EXPECT_EQ(0, merge_result.num_items_deleted());
   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_before_association());
   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_after_association());
 
   merge_result =
       cache()->MergeDataAndStartSyncing(syncer::FAVICON_TRACKING,
                                         syncer::SyncDataList(),
                                         CreateAndPassProcessor(),
                                         CreateAndPassSyncErrorFactory());
-  EXPECT_EQ((unsigned long)kFaviconBatchSize,
+  EXPECT_EQ(static_cast<size_t>(kFaviconBatchSize),
             cache()->GetAllSyncData(syncer::FAVICON_TRACKING).size());
   change_list = processor()->GetAndResetChangeList();
   EXPECT_TRUE(VerifyChanges(syncer::FAVICON_TRACKING,
                             expected_change_types,
                             expected_icons,
                             change_list));
   EXPECT_EQ(0, merge_result.num_items_added());
   EXPECT_EQ(0, merge_result.num_items_modified());
   EXPECT_EQ(0, merge_result.num_items_deleted());
   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_before_association());
@@ skipping 24 matching lines @@
         base::Time(),
         syncer::AttachmentIdList(),
         syncer::AttachmentServiceProxyForTest::Create()));
   }
 
   syncer::SyncMergeResult merge_result =
       cache()->MergeDataAndStartSyncing(syncer::FAVICON_IMAGES,
                                         initial_image_data,
                                         CreateAndPassProcessor(),
                                         CreateAndPassSyncErrorFactory());
-  EXPECT_EQ((unsigned long)kFaviconBatchSize,
+  EXPECT_EQ(static_cast<size_t>(kFaviconBatchSize),
             cache()->GetAllSyncData(syncer::FAVICON_IMAGES).size());
   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_added());
   EXPECT_EQ(0, merge_result.num_items_modified());
   EXPECT_EQ(0, merge_result.num_items_deleted());
   EXPECT_EQ(0, merge_result.num_items_before_association());
   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_after_association());
 
   merge_result =
       cache()->MergeDataAndStartSyncing(syncer::FAVICON_TRACKING,
                                         initial_tracking_data,
                                         CreateAndPassProcessor(),
                                         CreateAndPassSyncErrorFactory());
-  EXPECT_EQ((unsigned long)kFaviconBatchSize,
+  EXPECT_EQ(static_cast<size_t>(kFaviconBatchSize),
             cache()->GetAllSyncData(syncer::FAVICON_TRACKING).size());
   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
   EXPECT_EQ(0, merge_result.num_items_added());
   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_modified());
   EXPECT_EQ(0, merge_result.num_items_deleted());
   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_before_association());
   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_after_association());
 
   ASSERT_TRUE(VerifyLocalIcons(expected_icons));
 }
@@ skipping 44 matching lines @@
         base::Time(),
         syncer::AttachmentIdList(),
         syncer::AttachmentServiceProxyForTest::Create()));
   }
 
   syncer::SyncMergeResult merge_result =
       cache()->MergeDataAndStartSyncing(syncer::FAVICON_IMAGES,
                                         initial_image_data,
                                         CreateAndPassProcessor(),
                                         CreateAndPassSyncErrorFactory());
-  EXPECT_EQ((unsigned long)kFaviconBatchSize,
+  EXPECT_EQ(static_cast<size_t>(kFaviconBatchSize),
             cache()->GetAllSyncData(syncer::FAVICON_IMAGES).size());
   syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
-  EXPECT_EQ((unsigned long)kFaviconBatchSize/2, changes.size());
+  EXPECT_EQ(static_cast<size_t>(kFaviconBatchSize)/2, changes.size());
   EXPECT_EQ(0, merge_result.num_items_added());
   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_modified());
   EXPECT_EQ(0, merge_result.num_items_deleted());
   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_before_association());
   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_after_association());
 
   merge_result =
       cache()->MergeDataAndStartSyncing(syncer::FAVICON_TRACKING,
                                         initial_tracking_data,
                                         CreateAndPassProcessor(),
                                         CreateAndPassSyncErrorFactory());
-  EXPECT_EQ((unsigned long)kFaviconBatchSize,
+  EXPECT_EQ(static_cast<size_t>(kFaviconBatchSize),
             cache()->GetAllSyncData(syncer::FAVICON_TRACKING).size());
   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
   EXPECT_EQ(0, merge_result.num_items_added());
   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_modified());
   EXPECT_EQ(0, merge_result.num_items_deleted());
   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_before_association());
   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_after_association());
 
   ASSERT_TRUE(VerifyLocalIcons(expected_icons));
   ASSERT_TRUE(VerifyLocalCustomIcons(expected_data));
@@ skipping 49 matching lines @@
         base::Time(),
         syncer::AttachmentIdList(),
         syncer::AttachmentServiceProxyForTest::Create()));
   }
 
   syncer::SyncMergeResult merge_result =
       cache()->MergeDataAndStartSyncing(syncer::FAVICON_IMAGES,
                                         initial_image_data,
                                         CreateAndPassProcessor(),
                                         CreateAndPassSyncErrorFactory());
-  EXPECT_EQ((unsigned long)kFaviconBatchSize,
+  EXPECT_EQ(static_cast<size_t>(kFaviconBatchSize),
             cache()->GetAllSyncData(syncer::FAVICON_IMAGES).size());
   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
   EXPECT_EQ(0, merge_result.num_items_added());
   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_modified());
   EXPECT_EQ(0, merge_result.num_items_deleted());
   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_before_association());
   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_after_association());
 
   merge_result =
       cache()->MergeDataAndStartSyncing(syncer::FAVICON_TRACKING,
                                         initial_tracking_data,
                                         CreateAndPassProcessor(),
                                         CreateAndPassSyncErrorFactory());
-  EXPECT_EQ((unsigned long)kFaviconBatchSize,
+  EXPECT_EQ(static_cast<size_t>(kFaviconBatchSize),
             cache()->GetAllSyncData(syncer::FAVICON_TRACKING).size());
   syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
-  EXPECT_EQ((unsigned long)kFaviconBatchSize/2, changes.size());
+  EXPECT_EQ(static_cast<size_t>(kFaviconBatchSize)/2, changes.size());
   EXPECT_EQ(0, merge_result.num_items_added());
   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_modified());
   EXPECT_EQ(0, merge_result.num_items_deleted());
   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_before_association());
   EXPECT_EQ(kFaviconBatchSize, merge_result.num_items_after_association());
 
   ASSERT_TRUE(VerifyLocalIcons(expected_icons));
   ASSERT_TRUE(VerifyLocalCustomIcons(expected_data));
   ASSERT_TRUE(VerifyChanges(syncer::FAVICON_TRACKING,
                             expected_change_types,
@@ skipping 39 matching lines @@
         syncer::AttachmentIdList(),
         syncer::AttachmentServiceProxyForTest::Create()));
   }
 
   SetUpInitialSync(initial_image_data, initial_tracking_data);
 
   // Now receive the same icons as an update, but with missing image data.
   cache()->ProcessSyncChanges(FROM_HERE, stale_changes);
   syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
   ASSERT_TRUE(VerifyLocalIcons(expected_icons));
-  ASSERT_EQ((unsigned long)kFaviconBatchSize, changes.size());
+  ASSERT_EQ(static_cast<size_t>(kFaviconBatchSize), changes.size());
   ASSERT_TRUE(VerifyChanges(syncer::FAVICON_IMAGES,
                             expected_change_types,
                             expected_icons,
                             changes));
 }
 
 // New icons should be added locally without pushing anything back to the
 // remote syncer.
 TEST_F(SyncFaviconCacheTest, ReceiveNewImages) {
   syncer::SyncDataList initial_image_data, initial_tracking_data;
@@ skipping 124 matching lines @@
             syncer::AttachmentIdList(),
             syncer::AttachmentServiceProxyForTest::Create())));
   }
 
   SetUpInitialSync(initial_image_data, initial_tracking_data);
 
   // Now receive the same icons as an update, but with missing image data.
   cache()->ProcessSyncChanges(FROM_HERE, stale_changes);
   syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
   ASSERT_TRUE(VerifyLocalIcons(expected_icons));
-  ASSERT_EQ((unsigned long)kFaviconBatchSize, changes.size());
+  ASSERT_EQ(static_cast<size_t>(kFaviconBatchSize), changes.size());
   ASSERT_TRUE(VerifyChanges(syncer::FAVICON_TRACKING,
                             expected_change_types,
                             expected_icons,
                             changes));
 }
 
 // New tracking information should be added locally without pushing anything
 // back to the remote syncer.
 TEST_F(SyncFaviconCacheTest, ReceiveNewTracking) {
   syncer::SyncDataList initial_image_data, initial_tracking_data;
@@ skipping 122 matching lines @@
             image_specifics,
             base::Time(),
             syncer::AttachmentIdList(),
             syncer::AttachmentServiceProxyForTest::Create())));
   }
 
   SetUpInitialSync(initial_image_data, initial_tracking_data);
 
   // Now receive the tracking deletions. Since we'll still have orphan data,
   // the favicon count should remain the same.
-  EXPECT_EQ((unsigned long)kFaviconBatchSize, GetFaviconCount());
+  EXPECT_EQ(static_cast<size_t>(kFaviconBatchSize), GetFaviconCount());
   cache()->ProcessSyncChanges(FROM_HERE, tracking_deletions);
   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
-  EXPECT_EQ((unsigned long)kFaviconBatchSize, GetFaviconCount());
+  EXPECT_EQ(static_cast<size_t>(kFaviconBatchSize), GetFaviconCount());
 
   // Once the image deletions arrive, the favicon count should be 0 again.
   cache()->ProcessSyncChanges(FROM_HERE, image_deletions);
   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
   EXPECT_EQ(0U, GetFaviconCount());
 }
 
 // Ensure that MergeDataAndStartSyncing enforces the sync favicon limit by
 // dropping local icons.
 TEST_F(SyncFaviconCacheTest, ExpireOnMergeData) {
@@ skipping 30 matching lines @@
   }
 
   EXPECT_FALSE(VerifyLocalIcons(expected_icons));
 
   // Drops image part of the unsynced icons.
   syncer::SyncMergeResult merge_result =
       cache()->MergeDataAndStartSyncing(syncer::FAVICON_IMAGES,
                                         initial_image_data,
                                         CreateAndPassProcessor(),
                                         CreateAndPassSyncErrorFactory());
-  EXPECT_EQ((unsigned long)kMaxSyncFavicons * 2,
+  EXPECT_EQ(static_cast<size_t>(kMaxSyncFavicons)*2,
             GetFaviconCount());  // Still have tracking.
-  EXPECT_EQ((unsigned long)kMaxSyncFavicons,
+  EXPECT_EQ(static_cast<size_t>(kMaxSyncFavicons),
             cache()->GetAllSyncData(syncer::FAVICON_IMAGES).size());
   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
   EXPECT_EQ(kMaxSyncFavicons, merge_result.num_items_added());
   EXPECT_EQ(0, merge_result.num_items_modified());
   EXPECT_EQ(kMaxSyncFavicons, merge_result.num_items_deleted());
   EXPECT_EQ(kMaxSyncFavicons, merge_result.num_items_before_association());
   EXPECT_EQ(kMaxSyncFavicons * 2, merge_result.num_items_after_association());
 
   // Drops tracking part of the unsynced icons.
   merge_result =
       cache()->MergeDataAndStartSyncing(syncer::FAVICON_TRACKING,
                                         initial_tracking_data,
                                         CreateAndPassProcessor(),
                                         CreateAndPassSyncErrorFactory());
-  EXPECT_EQ((unsigned long)kMaxSyncFavicons,
+  EXPECT_EQ(static_cast<size_t>(kMaxSyncFavicons),
             cache()->GetAllSyncData(syncer::FAVICON_TRACKING).size());
   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
   EXPECT_EQ(0, merge_result.num_items_added());
   EXPECT_EQ(kMaxSyncFavicons, merge_result.num_items_modified());
   EXPECT_EQ(kMaxSyncFavicons, merge_result.num_items_deleted());
   EXPECT_EQ(kMaxSyncFavicons * 2, merge_result.num_items_before_association());
   EXPECT_EQ(kMaxSyncFavicons, merge_result.num_items_after_association());
 
   EXPECT_TRUE(VerifyLocalIcons(expected_icons));
 }
@@ skipping 45 matching lines @@
             1,
             tracking_specifics,
             base::Time(),
             syncer::AttachmentIdList(),
             syncer::AttachmentServiceProxyForTest::Create())));
   }
 
   SetUpInitialSync(initial_image_data, initial_tracking_data);
 
   // Now receive the new icons as an update.
-  EXPECT_EQ((unsigned long)kMaxSyncFavicons, GetFaviconCount());
+  EXPECT_EQ(static_cast<size_t>(kMaxSyncFavicons), GetFaviconCount());
   cache()->ProcessSyncChanges(FROM_HERE, image_changes);
   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
   cache()->ProcessSyncChanges(FROM_HERE, tracking_changes);
   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
   EXPECT_TRUE(VerifyLocalIcons(expected_icons));
-  EXPECT_GT(GetFaviconCount(), (unsigned long)kMaxSyncFavicons);
+  EXPECT_LT(static_cast<size_t>(kMaxSyncFavicons), GetFaviconCount());
 }
 
 // Test that visiting a new page triggers a favicon load and a sync addition.
 TEST_F(SyncFaviconCacheTest, AddOnFaviconVisited) {
   EXPECT_EQ(0U, GetFaviconCount());
   SetUpInitialSync(syncer::SyncDataList(), syncer::SyncDataList());
   std::vector<int> expected_icons;
 
   for (int i = 0; i < kFaviconBatchSize; ++i) {
     expected_icons.push_back(i);
     TestFaviconData test_data = BuildFaviconData(i);
     cache()->OnFaviconVisited(test_data.page_url, test_data.icon_url);
   }
 
-  EXPECT_EQ((unsigned long)kFaviconBatchSize, GetTaskCount());
+  EXPECT_EQ(static_cast<size_t>(kFaviconBatchSize), GetTaskCount());
 
   for (int i = 0; i < kFaviconBatchSize; ++i) {
     TestFaviconData test_data = BuildFaviconData(i);
     OnCustomFaviconDataAvailable(test_data);
 
     syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
     ASSERT_EQ(2U, changes.size());
     EXPECT_EQ(syncer::SyncChange::ACTION_ADD, changes[0].change_type());
     EXPECT_EQ(syncer::FAVICON_IMAGES, changes[0].sync_data().GetDataType());
     EXPECT_TRUE(
         CompareFaviconDataToSpecifics(test_data,
                                       changes[0].sync_data().GetSpecifics()));
     EXPECT_EQ(syncer::FAVICON_TRACKING, changes[1].sync_data().GetDataType());
     // Just verify the favicon url for the tracking specifics and that the
     // timestamp is non-null.
     EXPECT_EQ(syncer::SyncChange::ACTION_ADD, changes[1].change_type());
     EXPECT_EQ(test_data.icon_url.spec(),
               changes[1].sync_data().GetSpecifics().favicon_tracking().
                   favicon_url());
     EXPECT_NE(changes[1].sync_data().GetSpecifics().favicon_tracking().
                   last_visit_time_ms(), 0);
   }
 
   EXPECT_EQ(0U, GetTaskCount());
-  EXPECT_EQ((unsigned long)kFaviconBatchSize, GetFaviconCount());
+  EXPECT_EQ(static_cast<size_t>(kFaviconBatchSize), GetFaviconCount());
 }
 
 // Test that visiting a known page does not trigger a favicon load and just
 // updates the sync tracking info.
 TEST_F(SyncFaviconCacheTest, UpdateOnFaviconVisited) {
   EXPECT_EQ(0U, GetFaviconCount());
   SetUpInitialSync(syncer::SyncDataList(), syncer::SyncDataList());
   std::vector<int> expected_icons;
 
   // Add the favicons.
@@ skipping 16 matching lines @@
     // Just verify the favicon url for the tracking specifics and that the
     // timestamp is non-null.
     EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, changes[0].change_type());
     EXPECT_EQ(test_data.icon_url.spec(),
               changes[0].sync_data().GetSpecifics().favicon_tracking().
                   favicon_url());
     EXPECT_NE(changes[0].sync_data().GetSpecifics().favicon_tracking().
                   last_visit_time_ms(), 0);
   }
   EXPECT_EQ(0U, GetTaskCount());
-  EXPECT_EQ((unsigned long)kFaviconBatchSize, GetFaviconCount());
+  EXPECT_EQ(static_cast<size_t>(kFaviconBatchSize), GetFaviconCount());
 }
 
 // Ensure we properly expire old synced favicons as new ones are updated.
 TEST_F(SyncFaviconCacheTest, ExpireOnFaviconVisited) {
   EXPECT_EQ(0U, GetFaviconCount());
   SetUpInitialSync(syncer::SyncDataList(), syncer::SyncDataList());
   std::vector<int> expected_icons;
 
   // Add the initial favicons.
   for (int i = 0; i < kMaxSyncFavicons; ++i) {
@@ skipping 27 matching lines @@
               changes[2].sync_data().GetSpecifics().favicon_tracking().
                   favicon_url());
     EXPECT_NE(changes[2].sync_data().GetSpecifics().favicon_tracking().
                   last_visit_time_ms(), 0);
     EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, changes[3].change_type());
     EXPECT_EQ(old_favicon.icon_url.spec(),
               syncer::SyncDataLocal(changes[3].sync_data()).GetTag());
   }
 
   EXPECT_EQ(0U, GetTaskCount());
-  EXPECT_EQ((unsigned long)kMaxSyncFavicons, GetFaviconCount());
+  EXPECT_EQ(static_cast<size_t>(kMaxSyncFavicons), GetFaviconCount());
 }
 
 // A full history clear notification should result in all synced favicons being
 // deleted.
 TEST_F(SyncFaviconCacheTest, HistoryFullClear) {
   syncer::SyncDataList initial_image_data, initial_tracking_data;
   std::vector<int> expected_icons;
   std::vector<syncer::SyncChange::SyncChangeType> expected_deletions;
   for (int i = 0; i < kFaviconBatchSize; ++i) {
     expected_icons.push_back(i);
@@ skipping 15 matching lines @@
         tracking_specifics,
         base::Time(),
         syncer::AttachmentIdList(),
         syncer::AttachmentServiceProxyForTest::Create()));
   }
 
   SetUpInitialSync(initial_image_data, initial_tracking_data);
   syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
   EXPECT_TRUE(changes.empty());
 
-  EXPECT_EQ((unsigned long)kFaviconBatchSize, GetFaviconCount());
+  EXPECT_EQ(static_cast<size_t>(kFaviconBatchSize), GetFaviconCount());
   cache()->OnURLsDeleted(nullptr, true, false, history::URLRows(),
                          std::set<GURL>());
   EXPECT_EQ(0U, GetFaviconCount());
   changes = processor()->GetAndResetChangeList();
-  ASSERT_EQ(changes.size(), (unsigned long)kFaviconBatchSize*2);
+  ASSERT_EQ(changes.size(), static_cast<size_t>(kFaviconBatchSize)*2);
   syncer::SyncChangeList changes_1, changes_2;
   for (int i = 0; i < kFaviconBatchSize; ++i) {
     changes_1.push_back(changes[i]);
     changes_2.push_back(changes[i + kFaviconBatchSize]);
   }
   VerifyChanges(syncer::FAVICON_IMAGES,
                 expected_deletions,
                 expected_icons,
                 changes_1);
   VerifyChanges(syncer::FAVICON_TRACKING,
@@ skipping 32 matching lines @@
         tracking_specifics,
         base::Time(),
         syncer::AttachmentIdList(),
         syncer::AttachmentServiceProxyForTest::Create()));
   }
 
   SetUpInitialSync(initial_image_data, initial_tracking_data);
   syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
   EXPECT_TRUE(changes.empty());
 
-  EXPECT_EQ((unsigned long)kFaviconBatchSize, GetFaviconCount());
+  EXPECT_EQ(static_cast<size_t>(kFaviconBatchSize), GetFaviconCount());
   cache()->OnURLsDeleted(nullptr, false, false, history::URLRows(),
                          favicon_urls_to_delete);
-  EXPECT_EQ((unsigned long)kFaviconBatchSize/2, GetFaviconCount());
+  EXPECT_EQ(static_cast<size_t>(kFaviconBatchSize)/2, GetFaviconCount());
   changes = processor()->GetAndResetChangeList();
-  ASSERT_EQ(changes.size(), (unsigned long)kFaviconBatchSize);
+  ASSERT_EQ(changes.size(), static_cast<size_t>(kFaviconBatchSize));
   syncer::SyncChangeList changes_1, changes_2;
   for (size_t i = 0; i < kFaviconBatchSize/2; ++i) {
     changes_1.push_back(changes[i]);
     changes_2.push_back(changes[i + kFaviconBatchSize/2]);
   }
   VerifyChanges(syncer::FAVICON_IMAGES,
                 expected_deletions,
                 expected_icons,
                 changes_1);
   VerifyChanges(syncer::FAVICON_TRACKING,
                 expected_deletions,
                 expected_icons,
                 changes_2);
 }
 
 // Any favicon urls with the "data" scheme should be ignored.
 TEST_F(SyncFaviconCacheTest, IgnoreDataScheme) {
   EXPECT_EQ(0U, GetFaviconCount());
   SetUpInitialSync(syncer::SyncDataList(), syncer::SyncDataList());
   std::vector<int> expected_icons;
 
   for (int i = 0; i < kFaviconBatchSize; ++i) {
     TestFaviconData test_data = BuildFaviconData(i);
     cache()->OnFaviconVisited(test_data.page_url, GURL());
   }
 
-  EXPECT_EQ((unsigned long)kFaviconBatchSize, GetTaskCount());
+  EXPECT_EQ(static_cast<size_t>(kFaviconBatchSize), GetTaskCount());
 
   for (int i = 0; i < kFaviconBatchSize; ++i) {
     TestFaviconData test_data = BuildFaviconData(i);
     test_data.icon_url = GURL("data:image/png;base64;blabla");
     EXPECT_TRUE(test_data.icon_url.is_valid());
     OnCustomFaviconDataAvailable(test_data);
   }
 
   EXPECT_EQ(0U, GetTaskCount());
   EXPECT_EQ(0U, GetFaviconCount());
   syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
   EXPECT_TRUE(changes.empty());
 }
 
 // When visiting a page we've already loaded the favicon for, don't attempt to
 // reload the favicon, just update the visit time using the cached icon url.
 TEST_F(SyncFaviconCacheTest, ReuseCachedIconUrl) {
   EXPECT_EQ(0U, GetFaviconCount());
   SetUpInitialSync(syncer::SyncDataList(), syncer::SyncDataList());
   std::vector<int> expected_icons;
 
   for (int i = 0; i < kFaviconBatchSize; ++i) {
     expected_icons.push_back(i);
     TestFaviconData test_data = BuildFaviconData(i);
     cache()->OnFaviconVisited(test_data.page_url, test_data.icon_url);
   }
 
-  EXPECT_EQ((unsigned long)kFaviconBatchSize, GetTaskCount());
+  EXPECT_EQ(static_cast<size_t>(kFaviconBatchSize), GetTaskCount());
 
   for (int i = 0; i < kFaviconBatchSize; ++i) {
     TestFaviconData test_data = BuildFaviconData(i);
     OnCustomFaviconDataAvailable(test_data);
   }
   processor()->GetAndResetChangeList();
   EXPECT_EQ(0U, GetTaskCount());
-  EXPECT_EQ((unsigned long)kFaviconBatchSize, GetFaviconCount());
+  EXPECT_EQ(static_cast<size_t>(kFaviconBatchSize), GetFaviconCount());
 
   for (int i = 0; i < kFaviconBatchSize; ++i) {
     TestFaviconData test_data = BuildFaviconData(i);
     cache()->OnFaviconVisited(test_data.page_url, test_data.icon_url);
     syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
     ASSERT_EQ(1U, changes.size());
     // Just verify the favicon url for the tracking specifics and that the
     // timestamp is non-null.
     EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, changes[0].change_type());
     EXPECT_EQ(test_data.icon_url.spec(),
@@ skipping 42 matching lines @@
               tracking_specifics,
               base::Time(),
               syncer::AttachmentIdList(),
               syncer::AttachmentServiceProxyForTest::Create())));
     }
   }
 
   cache()->ProcessSyncChanges(FROM_HERE, initial_image_changes);
   cache()->ProcessSyncChanges(FROM_HERE, initial_tracking_changes);
   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
-  EXPECT_EQ((unsigned long)kFaviconBatchSize, GetFaviconCount());
+  EXPECT_EQ(static_cast<size_t>(kFaviconBatchSize), GetFaviconCount());
 
   for (int i = 0; i < kFaviconBatchSize/2; ++i) {
     TestFaviconData test_data = BuildFaviconData(i);
     cache()->OnFaviconVisited(test_data.page_url, GURL());
     EXPECT_EQ(1U, GetTaskCount());
     OnCustomFaviconDataAvailable(test_data);
     syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
 
     // Even favicons had image data, so should now receive new tracking data
     // and updated image data (we allow one update after the initial add).
@@ skipping 20 matching lines @@
       EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, changes[1].change_type());
       EXPECT_EQ(test_data.icon_url.spec(),
                 changes[1].sync_data().GetSpecifics().favicon_tracking().
                     favicon_url());
       EXPECT_NE(changes[1].sync_data().GetSpecifics().favicon_tracking().
                     last_visit_time_ms(), 0);
     }
   }
 
   EXPECT_EQ(0U, GetTaskCount());
-  EXPECT_EQ((unsigned long)kFaviconBatchSize, GetFaviconCount());
+  EXPECT_EQ(static_cast<size_t>(kFaviconBatchSize), GetFaviconCount());
 }
 
 // Verify that orphaned favicon images don't result in creating invalid
 // favicon tracking data.
 TEST_F(SyncFaviconCacheTest, PartialAssociationInfo) {
   syncer::SyncDataList initial_image_data, initial_tracking_data;
   for (int i = 0; i < kFaviconBatchSize; ++i) {
     sync_pb::EntitySpecifics image_specifics;
     FillImageSpecifics(BuildFaviconData(i),
                        image_specifics.mutable_favicon_image());
     initial_image_data.push_back(syncer::SyncData::CreateRemoteData(
         1,
         image_specifics,
         base::Time(),
         syncer::AttachmentIdList(),
         syncer::AttachmentServiceProxyForTest::Create()));
     image_specifics.mutable_favicon_image()->clear_favicon_web();
   }
 
   SetUpInitialSync(initial_image_data, initial_tracking_data);
   syncer::SyncChangeList change_list = processor()->GetAndResetChangeList();
   EXPECT_TRUE(change_list.empty());
-  EXPECT_EQ((unsigned long)kFaviconBatchSize, GetFaviconCount());
+  EXPECT_EQ(static_cast<size_t>(kFaviconBatchSize), GetFaviconCount());
 }
 
 // Tests that we don't choke if a favicon visit node with a null visit time is
 // present (see crbug.com/258196) and an update is made.
 TEST_F(SyncFaviconCacheTest, NullFaviconVisitTime) {
   EXPECT_EQ(0U, GetFaviconCount());
 
   syncer::SyncDataList initial_image_data, initial_tracking_data;
   std::vector<int> expected_icons;
   for (int i = 0; i < kFaviconBatchSize; ++i) {
@@ skipping 21 matching lines @@
 
   cache()->MergeDataAndStartSyncing(syncer::FAVICON_IMAGES,
                                     initial_image_data,
                                     CreateAndPassProcessor(),
                                     CreateAndPassSyncErrorFactory());
   ASSERT_EQ(0U, processor()->GetAndResetChangeList().size());
   cache()->MergeDataAndStartSyncing(syncer::FAVICON_TRACKING,
                                     initial_tracking_data,
                                     CreateAndPassProcessor(),
                                     CreateAndPassSyncErrorFactory());
-  ASSERT_EQ((unsigned long)kFaviconBatchSize,
+  ASSERT_EQ(static_cast<size_t>(kFaviconBatchSize),
             processor()->GetAndResetChangeList().size());
-  EXPECT_EQ((unsigned long)kFaviconBatchSize, GetFaviconCount());
+  EXPECT_EQ(static_cast<size_t>(kFaviconBatchSize), GetFaviconCount());
 
   // Visit the favicons again.
   EXPECT_EQ(0U, GetTaskCount());
   for (int i = 0; i < kFaviconBatchSize; ++i) {
     TestFaviconData test_data = BuildFaviconData(i);
     cache()->OnFaviconVisited(test_data.page_url, test_data.icon_url);
 
     syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
     ASSERT_EQ(1U, changes.size());
     // Just verify the favicon url for the tracking specifics and that the
     // timestamp is non-null.
     EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, changes[0].change_type());
     EXPECT_EQ(test_data.icon_url.spec(),
               changes[0].sync_data().GetSpecifics().favicon_tracking().
                   favicon_url());
     EXPECT_NE(changes[0].sync_data().GetSpecifics().favicon_tracking().
                   last_visit_time_ms(), 0);
   }
   EXPECT_EQ(0U, GetTaskCount());
-  EXPECT_EQ((unsigned long)kFaviconBatchSize, GetFaviconCount());
+  EXPECT_EQ(static_cast<size_t>(kFaviconBatchSize), GetFaviconCount());
 }
 
 // If another synced client has a clock skewed towards the future, it's possible
 // that favicons added locally will be expired as they are added. Ensure this
 // doesn't crash (see crbug.com/306150).
 TEST_F(SyncFaviconCacheTest, VisitFaviconClockSkew) {
   EXPECT_EQ(0U, GetFaviconCount());
   const int kClockSkew = 20;  // 20 minutes in the future.
 
   // Set up sync with kMaxSyncFavicons starting kClockSkew minutes in the
@@ skipping 39 matching lines @@
     ASSERT_EQ(changes[0].change_type(), syncer::SyncChange::ACTION_ADD);
     ASSERT_EQ(changes[0].sync_data().GetDataType(), syncer::FAVICON_IMAGES);
     ASSERT_EQ(changes[1].change_type(), syncer::SyncChange::ACTION_DELETE);
     ASSERT_EQ(changes[1].sync_data().GetDataType(), syncer::FAVICON_IMAGES);
     ASSERT_EQ(changes[2].change_type(), syncer::SyncChange::ACTION_ADD);
     ASSERT_EQ(changes[2].sync_data().GetDataType(), syncer::FAVICON_TRACKING);
     ASSERT_EQ(changes[3].change_type(), syncer::SyncChange::ACTION_DELETE);
     ASSERT_EQ(changes[3].sync_data().GetDataType(), syncer::FAVICON_TRACKING);
   }
   EXPECT_EQ(0U, GetTaskCount());
-  EXPECT_EQ((unsigned long)kMaxSyncFavicons, GetFaviconCount());
+  EXPECT_EQ(static_cast<size_t>(kMaxSyncFavicons), GetFaviconCount());
 }
 
 // Simulate a case where the set of tracking info and image info doesn't match,
 // and there is more tracking info than the max. A local update should correctly
 // determine whether to update/add an image/tracking entity.
 TEST_F(SyncFaviconCacheTest, MixedThreshold) {
   // First go through and add local favicons.
   for (int i = kMaxSyncFavicons; i < kMaxSyncFavicons + 5; ++i) {
     TestFaviconData favicon = BuildFaviconData(i);
     TriggerSyncFaviconReceived(favicon.page_url,
@@ skipping 27 matching lines @@
         syncer::AttachmentIdList(),
         syncer::AttachmentServiceProxyForTest::Create()));
   }
   SetUpInitialSync(initial_image_data, initial_tracking_data);
 
   // The local unsynced tracking info should be dropped, but not deleted.
   EXPECT_EQ(0U, processor()->GetAndResetChangeList().size());
 
   // Because the image and tracking data don't overlap, the total number of
   // favicons is still over the limit.
-  EXPECT_EQ((unsigned long)kMaxSyncFavicons + 5, GetFaviconCount());
+  EXPECT_EQ(static_cast<size_t>(kMaxSyncFavicons)+5, GetFaviconCount());
 
   // Trigger a tracking change for one of the favicons whose tracking info
   // was dropped, resulting in a tracking add and expiration of the orphaned
   // images.
   TestFaviconData test_data = BuildFaviconData(kMaxSyncFavicons);
   cache()->OnFaviconVisited(test_data.page_url, test_data.icon_url);
 
   syncer::SyncChangeList changes = processor()->GetAndResetChangeList();
   // 1 image update, 5 image deletions, 1 tracking deletion.
   ASSERT_EQ(6U, changes.size());
@@ skipping 17 matching lines @@
   EXPECT_EQ(changes[4].change_type(), syncer::SyncChange::ACTION_ADD);
   EXPECT_EQ(changes[4].sync_data().GetDataType(), syncer::FAVICON_TRACKING);
   EXPECT_EQ(kMaxSyncFavicons, GetFaviconId(changes[4]));
   // Expire tracking for favicon[0].
   EXPECT_EQ(changes[5].change_type(), syncer::SyncChange::ACTION_DELETE);
   EXPECT_EQ(changes[5].sync_data().GetDataType(), syncer::FAVICON_TRACKING);
   EXPECT_EQ(0, GetFaviconId(changes[5]));
 }
 
 }  // namespace browser_sync