[CIF] Move all tests under CachedImageFetcher prefix

Change-Id: Id52bceaaa9ac8635192b7cb0cd7714aeff821615
Reviewed-on: https://chromium-review.googlesource.com/c/1487172Reviewed-by: Sky Malice <skym@chromium.org>
Reviewed-by: Filip Gorski <fgorski@chromium.org>
Commit-Queue: Brandon Wylie <wylieb@chromium.org>
Cr-Commit-Position: refs/heads/master@{#635710}

components/image_fetcher/core/cache/image_cache.h

@@ -53,7 +53,7 @@ class ImageCache : public base::RefCounted<ImageCache> {
   void DeleteImage(std::string url);
 
  private:
-  friend class ImageCacheTest;
+  friend class CachedImageFetcherImageCacheTest;
   friend class base::RefCounted<ImageCache>;
   ~ImageCache();
 

components/image_fetcher/core/cache/image_cache_unittest.cc

@@ -41,9 +41,9 @@ const int kOverMaxCacheSize = 65 * 1024 * 1024;
 
 }  // namespace
 
-class ImageCacheTest : public testing::Test {
+class CachedImageFetcherImageCacheTest : public testing::Test {
  public:
-  ImageCacheTest() {}
+  CachedImageFetcherImageCacheTest() {}
 
   void SetUp() override { ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); }
 
@@ -175,15 +175,15 @@ class ImageCacheTest : public testing::Test {
   base::test::ScopedTaskEnvironment scoped_task_environment_;
   base::HistogramTester histogram_tester_;
 
-  DISALLOW_COPY_AND_ASSIGN(ImageCacheTest);
+  DISALLOW_COPY_AND_ASSIGN(CachedImageFetcherImageCacheTest);
 };
 
-TEST_F(ImageCacheTest, HashUrlToKeyTest) {
+TEST_F(CachedImageFetcherImageCacheTest, HashUrlToKeyTest) {
   ASSERT_EQ(ImageCache::HashUrlToKey("foo"), ImageCache::HashUrlToKey("foo"));
   ASSERT_NE(ImageCache::HashUrlToKey("foo"), ImageCache::HashUrlToKey("bar"));
 }
 
-TEST_F(ImageCacheTest, SanityTest) {
+TEST_F(CachedImageFetcherImageCacheTest, SanityTest) {
   CreateImageCache();
   InitializeImageCache();
 
@@ -193,7 +193,8 @@ TEST_F(ImageCacheTest, SanityTest) {
   EXPECT_CALL(*this, DataCallback(kImageData));
   image_cache()->LoadImage(
       false, kImageUrl,
-      base::BindOnce(&ImageCacheTest::DataCallback, base::Unretained(this)));
+      base::BindOnce(&CachedImageFetcherImageCacheTest::DataCallback,
+                     base::Unretained(this)));
   RunUntilIdle();
 
   image_cache()->DeleteImage(kImageUrl);
@@ -202,11 +203,12 @@ TEST_F(ImageCacheTest, SanityTest) {
   EXPECT_CALL(*this, DataCallback(std::string()));
   image_cache()->LoadImage(
       false, kImageUrl,
-      base::BindOnce(&ImageCacheTest::DataCallback, base::Unretained(this)));
+      base::BindOnce(&CachedImageFetcherImageCacheTest::DataCallback,
+                     base::Unretained(this)));
   RunUntilIdle();
 }
 
-TEST_F(ImageCacheTest, SaveCallsInitialization) {
+TEST_F(CachedImageFetcherImageCacheTest, SaveCallsInitialization) {
   CreateImageCache();
 
   ASSERT_FALSE(IsCacheInitialized());
@@ -217,7 +219,7 @@ TEST_F(ImageCacheTest, SaveCallsInitialization) {
   ASSERT_TRUE(IsCacheInitialized());
 }
 
-TEST_F(ImageCacheTest, Save) {
+TEST_F(CachedImageFetcherImageCacheTest, Save) {
   CreateImageCache();
   InitializeImageCache();
 
@@ -227,11 +229,12 @@ TEST_F(ImageCacheTest, Save) {
   EXPECT_CALL(*this, DataCallback(kImageData));
   image_cache()->LoadImage(
       false, kImageUrl,
-      base::BindOnce(&ImageCacheTest::DataCallback, base::Unretained(this)));
+      base::BindOnce(&CachedImageFetcherImageCacheTest::DataCallback,
+                     base::Unretained(this)));
   RunUntilIdle();
 }
 
-TEST_F(ImageCacheTest, Load) {
+TEST_F(CachedImageFetcherImageCacheTest, Load) {
   PrepareImageCache();
   auto metadata_before = GetMetadata(kImageUrlHashed);
 
@@ -239,7 +242,8 @@ TEST_F(ImageCacheTest, Load) {
   EXPECT_CALL(*this, DataCallback(kImageData));
   image_cache()->LoadImage(
       false, kImageUrl,
-      base::BindOnce(&ImageCacheTest::DataCallback, base::Unretained(this)));
+      base::BindOnce(&CachedImageFetcherImageCacheTest::DataCallback,
+                     base::Unretained(this)));
   RunUntilIdle();
   db()->LoadCallback(true);
   db()->UpdateCallback(true);
@@ -249,7 +253,7 @@ TEST_F(ImageCacheTest, Load) {
   ASSERT_FALSE(IsMetadataEqual(metadata_before, metadata_after));
 }
 
-TEST_F(ImageCacheTest, LoadReadOnly) {
+TEST_F(CachedImageFetcherImageCacheTest, LoadReadOnly) {
   PrepareImageCache();
   auto metadata_before = GetMetadata(kImageUrlHashed);
 
@@ -257,20 +261,22 @@ TEST_F(ImageCacheTest, LoadReadOnly) {
   EXPECT_CALL(*this, DataCallback(kImageData));
   image_cache()->LoadImage(
       true, kImageUrl,
-      base::BindOnce(&ImageCacheTest::DataCallback, base::Unretained(this)));
+      base::BindOnce(&CachedImageFetcherImageCacheTest::DataCallback,
+                     base::Unretained(this)));
   RunUntilIdle();
 
   auto metadata_after = GetMetadata(kImageUrlHashed);
   ASSERT_TRUE(IsMetadataEqual(metadata_before, metadata_after));
 }
 
-TEST_F(ImageCacheTest, Delete) {
+TEST_F(CachedImageFetcherImageCacheTest, Delete) {
   PrepareImageCache();
 
   EXPECT_CALL(*this, DataCallback(kImageData));
   image_cache()->LoadImage(
       false, kImageUrl,
-      base::BindOnce(&ImageCacheTest::DataCallback, base::Unretained(this)));
+      base::BindOnce(&CachedImageFetcherImageCacheTest::DataCallback,
+                     base::Unretained(this)));
   RunUntilIdle();
 
   image_cache()->DeleteImage(kImageUrl);
@@ -279,11 +285,12 @@ TEST_F(ImageCacheTest, Delete) {
   EXPECT_CALL(*this, DataCallback(std::string()));
   image_cache()->LoadImage(
       false, kImageUrl,
-      base::BindOnce(&ImageCacheTest::DataCallback, base::Unretained(this)));
+      base::BindOnce(&CachedImageFetcherImageCacheTest::DataCallback,
+                     base::Unretained(this)));
   RunUntilIdle();
 }
 
-TEST_F(ImageCacheTest, Eviction) {
+TEST_F(CachedImageFetcherImageCacheTest, Eviction) {
   PrepareImageCache();
 
   clock()->SetNow(clock()->Now() + base::TimeDelta::FromDays(7));
@@ -293,7 +300,8 @@ TEST_F(ImageCacheTest, Eviction) {
   EXPECT_CALL(*this, DataCallback(std::string()));
   image_cache()->LoadImage(
       false, kImageUrl,
-      base::BindOnce(&ImageCacheTest::DataCallback, base::Unretained(this)));
+      base::BindOnce(&CachedImageFetcherImageCacheTest::DataCallback,
+                     base::Unretained(this)));
   RunUntilIdle();
 
   histogram_tester().ExpectBucketCount(
@@ -304,7 +312,7 @@ TEST_F(ImageCacheTest, Eviction) {
       CachedImageFetcherEvent::kCacheStartupEvictionFinished, 1);
 }
 
-TEST_F(ImageCacheTest, EvictionWhenFull) {
+TEST_F(CachedImageFetcherImageCacheTest, EvictionWhenFull) {
   PrepareImageCache();
   InjectMetadata(kImageUrl, kOverMaxCacheSize);
   clock()->SetNow(clock()->Now() + base::TimeDelta::FromDays(6));
@@ -314,11 +322,12 @@ TEST_F(ImageCacheTest, EvictionWhenFull) {
   EXPECT_CALL(*this, DataCallback(""));
   image_cache()->LoadImage(
       false, kImageUrl,
-      base::BindOnce(&ImageCacheTest::DataCallback, base::Unretained(this)));
+      base::BindOnce(&CachedImageFetcherImageCacheTest::DataCallback,
+                     base::Unretained(this)));
   RunUntilIdle();
 }
 
-TEST_F(ImageCacheTest, EvictionTooSoon) {
+TEST_F(CachedImageFetcherImageCacheTest, EvictionTooSoon) {
   PrepareImageCache();
 
   clock()->SetNow(clock()->Now() + base::TimeDelta::FromDays(6));
@@ -327,11 +336,12 @@ TEST_F(ImageCacheTest, EvictionTooSoon) {
   EXPECT_CALL(*this, DataCallback(kImageData));
   image_cache()->LoadImage(
       false, kImageUrl,
-      base::BindOnce(&ImageCacheTest::DataCallback, base::Unretained(this)));
+      base::BindOnce(&CachedImageFetcherImageCacheTest::DataCallback,
+                     base::Unretained(this)));
   RunUntilIdle();
 }
 
-TEST_F(ImageCacheTest, EvictionWhenEvictionAlreadyPerformed) {
+TEST_F(CachedImageFetcherImageCacheTest, EvictionWhenEvictionAlreadyPerformed) {
   PrepareImageCache();
 
   prefs()->SetTime("cached_image_fetcher_last_startup_eviction_time",
@@ -342,11 +352,12 @@ TEST_F(ImageCacheTest, EvictionWhenEvictionAlreadyPerformed) {
   EXPECT_CALL(*this, DataCallback(kImageData));
   image_cache()->LoadImage(
       false, kImageUrl,
-      base::BindOnce(&ImageCacheTest::DataCallback, base::Unretained(this)));
+      base::BindOnce(&CachedImageFetcherImageCacheTest::DataCallback,
+                     base::Unretained(this)));
   RunUntilIdle();
 }
 
-TEST_F(ImageCacheTest, Reconciliation) {
+TEST_F(CachedImageFetcherImageCacheTest, Reconciliation) {
   CreateImageCache();
   InitializeImageCache();
 
@@ -359,14 +370,15 @@ TEST_F(ImageCacheTest, Reconciliation) {
   EXPECT_CALL(*this, DataCallback(std::string()));
   image_cache()->LoadImage(
       false, "foo",
-      base::BindOnce(&ImageCacheTest::DataCallback, base::Unretained(this)));
+      base::BindOnce(&CachedImageFetcherImageCacheTest::DataCallback,
+                     base::Unretained(this)));
   RunUntilIdle();
 
   // Metadata should be gone.
   ASSERT_FALSE(IsMetadataPresent("bar"));
 }
 
-TEST_F(ImageCacheTest, ReconciliationMismatchData) {
+TEST_F(CachedImageFetcherImageCacheTest, ReconciliationMismatchData) {
   CreateImageCache();
   InitializeImageCache();
 
@@ -380,11 +392,12 @@ TEST_F(ImageCacheTest, ReconciliationMismatchData) {
   EXPECT_CALL(*this, DataCallback(std::string()));
   image_cache()->LoadImage(
       false, "bar",
-      base::BindOnce(&ImageCacheTest::DataCallback, base::Unretained(this)));
+      base::BindOnce(&CachedImageFetcherImageCacheTest::DataCallback,
+                     base::Unretained(this)));
   RunUntilIdle();
 }
 
-TEST_F(ImageCacheTest, ReconciliationMismatchMetadata) {
+TEST_F(CachedImageFetcherImageCacheTest, ReconciliationMismatchMetadata) {
   CreateImageCache();
   InitializeImageCache();
 

components/image_fetcher/core/cache/image_data_store_disk_unittest.cc

@@ -26,9 +26,9 @@ constexpr char kImageKey[] = "key";
 constexpr char kImageData[] = "data";
 }  // namespace
 
-class ImageDataStoreDiskTest : public testing::Test {
+class CachedImageFetcherImageDataStoreDiskTest : public testing::Test {
  public:
-  ImageDataStoreDiskTest() {}
+  CachedImageFetcherImageDataStoreDiskTest() {}
   void SetUp() override { ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); }
 
   void CreateDataStore() {
@@ -39,8 +39,9 @@ class ImageDataStoreDiskTest : public testing::Test {
 
   void InitializeDataStore() {
     EXPECT_CALL(*this, OnInitialized());
-    data_store()->Initialize(base::BindOnce(
-        &ImageDataStoreDiskTest::OnInitialized, base::Unretained(this)));
+    data_store()->Initialize(
+        base::BindOnce(&CachedImageFetcherImageDataStoreDiskTest::OnInitialized,
+                       base::Unretained(this)));
     RunUntilIdle();
   }
 
@@ -61,8 +62,9 @@ class ImageDataStoreDiskTest : public testing::Test {
   void AssertDataPresent(const std::string& key, const std::string& data) {
     EXPECT_CALL(*this, DataCallback(data));
     data_store()->LoadImage(
-        key, base::BindOnce(&ImageDataStoreDiskTest::DataCallback,
-                            base::Unretained(this)));
+        key,
+        base::BindOnce(&CachedImageFetcherImageDataStoreDiskTest::DataCallback,
+                       base::Unretained(this)));
     RunUntilIdle();
   }
 
@@ -90,10 +92,10 @@ class ImageDataStoreDiskTest : public testing::Test {
 
   base::test::ScopedTaskEnvironment scoped_task_environment_;
 
-  DISALLOW_COPY_AND_ASSIGN(ImageDataStoreDiskTest);
+  DISALLOW_COPY_AND_ASSIGN(CachedImageFetcherImageDataStoreDiskTest);
 };
 
-TEST_F(ImageDataStoreDiskTest, SanityTest) {
+TEST_F(CachedImageFetcherImageDataStoreDiskTest, SanityTest) {
   CreateDataStore();
   InitializeDataStore();
 
@@ -104,7 +106,7 @@ TEST_F(ImageDataStoreDiskTest, SanityTest) {
   AssertDataPresent(kImageKey, "");
 }
 
-TEST_F(ImageDataStoreDiskTest, Init) {
+TEST_F(CachedImageFetcherImageDataStoreDiskTest, Init) {
   CreateDataStore();
   ASSERT_FALSE(data_store()->IsInitialized());
 
@@ -112,7 +114,7 @@ TEST_F(ImageDataStoreDiskTest, Init) {
   ASSERT_TRUE(data_store()->IsInitialized());
 }
 
-TEST_F(ImageDataStoreDiskTest, InitWithExistingDirectory) {
+TEST_F(CachedImageFetcherImageDataStoreDiskTest, InitWithExistingDirectory) {
   PrepareDataStore(/* initialize */ true);
 
   // Recreating the data store shouldn't wipe the directory.
@@ -122,18 +124,18 @@ TEST_F(ImageDataStoreDiskTest, InitWithExistingDirectory) {
   AssertDataPresent(kImageKey);
 }
 
-TEST_F(ImageDataStoreDiskTest, SaveBeforeInit) {
+TEST_F(CachedImageFetcherImageDataStoreDiskTest, SaveBeforeInit) {
   PrepareDataStore(/* initialize */ false);
   // No data should be present (empty string).
   AssertDataPresent(kImageKey, "");
 }
 
-TEST_F(ImageDataStoreDiskTest, Save) {
+TEST_F(CachedImageFetcherImageDataStoreDiskTest, Save) {
   PrepareDataStore(/* initialize */ true);
   AssertDataPresent(kImageKey);
 }
 
-TEST_F(ImageDataStoreDiskTest, DeleteBeforeInit) {
+TEST_F(CachedImageFetcherImageDataStoreDiskTest, DeleteBeforeInit) {
   PrepareDataStore(/* initialize */ false);
 
   DeleteData(kImageKey);
@@ -143,7 +145,7 @@ TEST_F(ImageDataStoreDiskTest, DeleteBeforeInit) {
   AssertDataPresent(kImageKey);
 }
 
-TEST_F(ImageDataStoreDiskTest, Delete) {
+TEST_F(CachedImageFetcherImageDataStoreDiskTest, Delete) {
   PrepareDataStore(/* initialize */ true);
 
   DeleteData(kImageKey);
@@ -152,35 +154,39 @@ TEST_F(ImageDataStoreDiskTest, Delete) {
   AssertDataPresent(kImageKey, "");
 }
 
-TEST_F(ImageDataStoreDiskTest, GetAllKeysBeforeInit) {
+TEST_F(CachedImageFetcherImageDataStoreDiskTest, GetAllKeysBeforeInit) {
   PrepareDataStore(/* initialize */ false);
 
   // Should return empty vector even though there is a file present.
   EXPECT_CALL(*this, KeysCallback(std::vector<std::string>()));
-  data_store()->GetAllKeys(base::BindOnce(&ImageDataStoreDiskTest::KeysCallback,
-                                          base::Unretained(this)));
+  data_store()->GetAllKeys(
+      base::BindOnce(&CachedImageFetcherImageDataStoreDiskTest::KeysCallback,
+                     base::Unretained(this)));
   RunUntilIdle();
 }
 
-TEST_F(ImageDataStoreDiskTest, GetAllKeys) {
+TEST_F(CachedImageFetcherImageDataStoreDiskTest, GetAllKeys) {
   PrepareDataStore(/* initialize */ true);
 
   // Should return empty vector even though there is a file present.
   EXPECT_CALL(*this, KeysCallback(std::vector<std::string>({kImageKey})));
-  data_store()->GetAllKeys(base::BindOnce(&ImageDataStoreDiskTest::KeysCallback,
-                                          base::Unretained(this)));
+  data_store()->GetAllKeys(
+      base::BindOnce(&CachedImageFetcherImageDataStoreDiskTest::KeysCallback,
+                     base::Unretained(this)));
   RunUntilIdle();
 }
 
-TEST_F(ImageDataStoreDiskTest, QueuedLoadIsServedBeforeDelete) {
+TEST_F(CachedImageFetcherImageDataStoreDiskTest,
+       QueuedLoadIsServedBeforeDelete) {
   CreateDataStore();
   InitializeDataStore();
 
   SaveData(kImageKey);
   EXPECT_CALL(*this, DataCallback(kImageData));
-  data_store()->LoadImage(kImageKey,
-                          base::BindOnce(&ImageDataStoreDiskTest::DataCallback,
-                                         base::Unretained(this)));
+  data_store()->LoadImage(
+      kImageKey,
+      base::BindOnce(&CachedImageFetcherImageDataStoreDiskTest::DataCallback,
+                     base::Unretained(this)));
   DeleteData(kImageKey);
 
   RunUntilIdle();

components/image_fetcher/core/cached_image_fetcher_unittest.cc

@@ -62,11 +62,11 @@ const char kNetworkLoadAfterCacheHitHistogram[] =
 
 }  // namespace
 
-class ComponentizedCachedImageFetcherTest : public testing::Test {
+class CachedImageFetcherTest : public testing::Test {
  public:
-  ComponentizedCachedImageFetcherTest() {}
+  CachedImageFetcherTest() {}
 
-  ~ComponentizedCachedImageFetcherTest() override {
+  ~CachedImageFetcherTest() override {
     cached_image_fetcher_.reset();
     // We need to run until idle after deleting the database, because
     // ProtoDatabase deletes the actual LevelDB asynchronously.
@@ -145,7 +145,7 @@ class ComponentizedCachedImageFetcherTest : public testing::Test {
   base::test::ScopedTaskEnvironment scoped_task_environment_;
   base::HistogramTester histogram_tester_;
 
-  DISALLOW_COPY_AND_ASSIGN(ComponentizedCachedImageFetcherTest);
+  DISALLOW_COPY_AND_ASSIGN(CachedImageFetcherTest);
 };
 
 MATCHER(EmptyImage, "") {
@@ -162,9 +162,7 @@ MATCHER(NonEmptyString, "") {
 
 // TODO(wylieb): Write a test that creates two CachedImageFetcher and tests
 // that they both can use what's inside.
-// TODO(wylieb): Rename these tests CachedImageFetcherTest* when ntp_snippets/-
-//               remote/cached_image_fetcher has been migrated.
-TEST_F(ComponentizedCachedImageFetcherTest, FetchImageFromCache) {
+TEST_F(CachedImageFetcherTest, FetchImageFromCache) {
   // Save the image in the database.
   image_cache()->SaveImage(kImageUrl.spec(), kImageData);
   RunUntilIdle();
@@ -188,7 +186,7 @@ TEST_F(ComponentizedCachedImageFetcherTest, FetchImageFromCache) {
                                        CachedImageFetcherEvent::kCacheHit, 1);
 }
 
-TEST_F(ComponentizedCachedImageFetcherTest, FetchImageFromCacheReadOnly) {
+TEST_F(CachedImageFetcherTest, FetchImageFromCacheReadOnly) {
   CreateCachedImageFetcher(/* read_only */ true);
   // Save the image in the database.
   image_cache()->SaveImage(kImageUrl.spec(), kImageData);
@@ -228,7 +226,7 @@ TEST_F(ComponentizedCachedImageFetcherTest, FetchImageFromCacheReadOnly) {
   }
 }
 
-TEST_F(ComponentizedCachedImageFetcherTest, FetchImagePopulatesCache) {
+TEST_F(CachedImageFetcherTest, FetchImagePopulatesCache) {
   // Expect the image to be fetched by URL.
   {
     test_url_loader_factory()->AddResponse(kImageUrl.spec(), kImageData);
@@ -257,7 +255,7 @@ TEST_F(ComponentizedCachedImageFetcherTest, FetchImagePopulatesCache) {
     EXPECT_CALL(*this, OnImageLoaded(NonEmptyString()));
     image_cache()->LoadImage(
         /* read_only */ false, kImageUrl.spec(),
-        base::BindOnce(&ComponentizedCachedImageFetcherTest::OnImageLoaded,
+        base::BindOnce(&CachedImageFetcherTest::OnImageLoaded,
                        base::Unretained(this)));
     RunUntilIdle();
   }
@@ -278,7 +276,7 @@ TEST_F(ComponentizedCachedImageFetcherTest, FetchImagePopulatesCache) {
   }
 }
 
-TEST_F(ComponentizedCachedImageFetcherTest, FetchImagePopulatesCacheReadOnly) {
+TEST_F(CachedImageFetcherTest, FetchImagePopulatesCacheReadOnly) {
   CreateCachedImageFetcher(/* read_only */ true);
   // Expect the image to be fetched by URL.
   {
@@ -308,13 +306,13 @@ TEST_F(ComponentizedCachedImageFetcherTest, FetchImagePopulatesCacheReadOnly) {
     EXPECT_CALL(*this, OnImageLoaded(std::string()));
     image_cache()->LoadImage(
         /* read_only */ false, kImageUrl.spec(),
-        base::BindOnce(&ComponentizedCachedImageFetcherTest::OnImageLoaded,
+        base::BindOnce(&CachedImageFetcherTest::OnImageLoaded,
                        base::Unretained(this)));
     RunUntilIdle();
   }
 }
 
-TEST_F(ComponentizedCachedImageFetcherTest, FetchDecodingErrorDeletesCache) {
+TEST_F(CachedImageFetcherTest, FetchDecodingErrorDeletesCache) {
   // Save the image in the database.
   image_cache()->SaveImage(kImageUrl.spec(), kImageData);
   RunUntilIdle();

components/ntp_snippets/remote/cached_image_fetcher_unittest.cc

@@ -72,9 +72,10 @@ enum class TestType {
 
 // This test is parameterized to run all tests in the three configurations:
 // both callbacks used, only image_callback used, only image_data_callback used.
-class CachedImageFetcherTest : public testing::TestWithParam<TestType> {
+class NtpSnippetsCachedImageFetcherTest
+    : public testing::TestWithParam<TestType> {
  public:
-  CachedImageFetcherTest() {
+  NtpSnippetsCachedImageFetcherTest() {
     EXPECT_TRUE(database_dir_.CreateUniqueTempDir());
 
     RequestThrottler::RegisterProfilePrefs(pref_service_.registry());
@@ -95,7 +96,7 @@ class CachedImageFetcherTest : public testing::TestWithParam<TestType> {
     EXPECT_TRUE(database_->IsInitialized());
   }
 
-  ~CachedImageFetcherTest() override {
+  ~NtpSnippetsCachedImageFetcherTest() override {
     cached_image_fetcher_.reset();
     database_.reset();
     // We need to run until idle after deleting the database, because
@@ -157,10 +158,10 @@ class CachedImageFetcherTest : public testing::TestWithParam<TestType> {
   TestingPrefServiceSimple pref_service_;
   base::test::ScopedTaskEnvironment scoped_task_environment_;
 
-  DISALLOW_COPY_AND_ASSIGN(CachedImageFetcherTest);
+  DISALLOW_COPY_AND_ASSIGN(NtpSnippetsCachedImageFetcherTest);
 };
 
-TEST_P(CachedImageFetcherTest, FetchImageFromCache) {
+TEST_P(NtpSnippetsCachedImageFetcherTest, FetchImageFromCache) {
   // Save the image in the database.
   database()->SaveImage(kSnippetID, kImageData);
   RunUntilIdle();
@@ -170,7 +171,7 @@ TEST_P(CachedImageFetcherTest, FetchImageFromCache) {
   Fetch(kImageData, true);
 }
 
-TEST_P(CachedImageFetcherTest, FetchImagePopulatesCache) {
+TEST_P(NtpSnippetsCachedImageFetcherTest, FetchImagePopulatesCache) {
   // Expect the image to be fetched by URL.
   {
     test_url_loader_factory()->AddResponse(kImageURL, kImageData);
@@ -183,7 +184,7 @@ TEST_P(CachedImageFetcherTest, FetchImagePopulatesCache) {
   }
 }
 
-TEST_P(CachedImageFetcherTest, FetchNonExistingImage) {
+TEST_P(NtpSnippetsCachedImageFetcherTest, FetchNonExistingImage) {
   const std::string kErrorResponse = "error-response";
   test_url_loader_factory()->AddResponse(kImageURL, kErrorResponse,
                                          net::HTTP_NOT_FOUND);
@@ -192,7 +193,7 @@ TEST_P(CachedImageFetcherTest, FetchNonExistingImage) {
 }
 
 INSTANTIATE_TEST_SUITE_P(,
-                         CachedImageFetcherTest,
+                         NtpSnippetsCachedImageFetcherTest,
                          testing::Values(TestType::kImageCallback,
                                          TestType::kImageDataCallback,
                                          TestType::kBothCallbacks));