[LargeIconService] Allow decoding of images in the service

components/favicon/core/large_icon_service_unittest.cc

 // Copyright 2015 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/favicon/core/large_icon_service.h"
 
 #include <deque>
 #include <memory>
 
 #include "base/bind.h"
@@ skipping 11 matching lines @@
 #include "components/favicon_base/favicon_types.h"
 #include "components/image_fetcher/core/image_fetcher.h"
 #include "components/image_fetcher/core/request_metadata.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/image/image.h"
+#include "ui/gfx/image/image_skia.h"
 #include "url/gurl.h"
 
 namespace favicon {
 namespace {
 
 using testing::NiceMock;
 using testing::Return;
 using testing::SaveArg;
 using testing::_;
 
@@ skipping 57 matching lines @@
 
 class LargeIconServiceTest : public testing::Test {
  public:
   LargeIconServiceTest()
       : mock_image_fetcher_(new NiceMock<MockImageFetcher>()),
         large_icon_service_(&mock_favicon_service_,
                             base::ThreadTaskRunnerHandle::Get(),
                             base::WrapUnique(mock_image_fetcher_)),
         is_callback_invoked_(false) {}
 
-  ~LargeIconServiceTest() override {
-  }
+  ~LargeIconServiceTest() override {}
 
-  void ResultCallback(const favicon_base::LargeIconResult& result) {
+  void RawBitmapResultCallback(const favicon_base::LargeIconResult& result) {
     is_callback_invoked_ = true;
 
     // Checking presence and absence of results.
     EXPECT_EQ(expected_bitmap_.is_valid(), result.bitmap.is_valid());
     EXPECT_EQ(expected_fallback_icon_style_ != nullptr,
               result.fallback_icon_style != nullptr);
 
     if (expected_bitmap_.is_valid()) {
       EXPECT_EQ(expected_bitmap_.pixel_size, result.bitmap.pixel_size);
       // Not actually checking bitmap content.
     }
     if (expected_fallback_icon_style_.get()) {
-      EXPECT_EQ(*expected_fallback_icon_style_,
-                *result.fallback_icon_style);
+      EXPECT_EQ(*expected_fallback_icon_style_, *result.fallback_icon_style);
     }
   }
 
+  void ImageResultCallback(const favicon_base::LargeIconImageResult& result) {
+    is_callback_invoked_ = true;
+
+    // Checking presence and absence of results.
+    EXPECT_EQ(expected_bitmap_.is_valid(), !result.image.IsEmpty());
+    EXPECT_EQ(expected_fallback_icon_style_ != nullptr,
+              result.fallback_icon_style != nullptr);
+
+    if (expected_bitmap_.is_valid()) {
+      EXPECT_EQ(expected_bitmap_.pixel_size,
+                result.image.ToImageSkia()->size());
+      // Not actually checking bitmap content.
+    }
+    if (expected_fallback_icon_style_.get()) {
+      EXPECT_EQ(*expected_fallback_icon_style_, *result.fallback_icon_style);
+    }
+  }
+
   void InjectMockResult(
       const GURL& page_url,
       const favicon_base::FaviconRawBitmapResult& mock_result) {
     EXPECT_CALL(mock_favicon_service_,
                 GetLargestRawFaviconForPageURL(page_url, _, _, _, _))
         .WillOnce(PostReply<5>(mock_result));
   }
 
  protected:
   base::MessageLoopForIO loop_;
 
   NiceMock<MockImageFetcher>* mock_image_fetcher_;
   testing::NiceMock<MockFaviconService> mock_favicon_service_;
   LargeIconService large_icon_service_;
   base::CancelableTaskTracker cancelable_task_tracker_;
 
   favicon_base::FaviconRawBitmapResult expected_bitmap_;
   std::unique_ptr<favicon_base::FallbackIconStyle>
       expected_fallback_icon_style_;
 
   bool is_callback_invoked_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(LargeIconServiceTest);
 };
 
-TEST_F(LargeIconServiceTest, SameSize) {
+TEST_F(LargeIconServiceTest, RawBitmapSameSize) {
   InjectMockResult(GURL(kDummyUrl), CreateTestBitmapResult(24, 24, kTestColor));
   expected_bitmap_ = CreateTestBitmapResult(24, 24, kTestColor);
   large_icon_service_.GetLargeIconOrFallbackStyle(
       GURL(kDummyUrl),
       24,  // |min_source_size_in_pixel|
       24,  // |desired_size_in_pixel|
-      base::Bind(&LargeIconServiceTest::ResultCallback, base::Unretained(this)),
-      &cancelable_task_tracker_);
-  base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(is_callback_invoked_);
-}
-
-TEST_F(LargeIconServiceTest, ScaleDown) {
+      base::Bind(&LargeIconServiceTest::RawBitmapResultCallback,
+                 base::Unretained(this)),
+      &cancelable_task_tracker_);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(is_callback_invoked_);
+}
+
+TEST_F(LargeIconServiceTest, ImageSameSize) {
+  InjectMockResult(GURL(kDummyUrl), CreateTestBitmapResult(24, 24, kTestColor));
+  expected_bitmap_ = CreateTestBitmapResult(24, 24, kTestColor);
+  large_icon_service_.GetLargeIconImageOrFallbackStyle(
+      GURL(kDummyUrl),
+      24,  // |min_source_size_in_pixel|
+      24,  // |desired_size_in_pixel|
+      base::Bind(&LargeIconServiceTest::ImageResultCallback,
+                 base::Unretained(this)),
+      &cancelable_task_tracker_);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(is_callback_invoked_);
+}
+
+TEST_F(LargeIconServiceTest, RawBitmapScaleDown) {
   InjectMockResult(GURL(kDummyUrl), CreateTestBitmapResult(32, 32, kTestColor));
   expected_bitmap_ = CreateTestBitmapResult(24, 24, kTestColor);
   large_icon_service_.GetLargeIconOrFallbackStyle(
       GURL(kDummyUrl), 24, 24,
-      base::Bind(&LargeIconServiceTest::ResultCallback, base::Unretained(this)),
-      &cancelable_task_tracker_);
-  base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(is_callback_invoked_);
-}
-
-TEST_F(LargeIconServiceTest, ScaleUp) {
+      base::Bind(&LargeIconServiceTest::RawBitmapResultCallback,
+                 base::Unretained(this)),
+      &cancelable_task_tracker_);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(is_callback_invoked_);
+}
+
+TEST_F(LargeIconServiceTest, ImageScaleDown) {
+  InjectMockResult(GURL(kDummyUrl), CreateTestBitmapResult(32, 32, kTestColor));
+  expected_bitmap_ = CreateTestBitmapResult(24, 24, kTestColor);
+  large_icon_service_.GetLargeIconImageOrFallbackStyle(
+      GURL(kDummyUrl), 24, 24,
+      base::Bind(&LargeIconServiceTest::ImageResultCallback,
+                 base::Unretained(this)),
+      &cancelable_task_tracker_);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(is_callback_invoked_);
+}
+
+TEST_F(LargeIconServiceTest, RawBitmapScaleUp) {
   InjectMockResult(GURL(kDummyUrl), CreateTestBitmapResult(16, 16, kTestColor));
   expected_bitmap_ = CreateTestBitmapResult(24, 24, kTestColor);
   large_icon_service_.GetLargeIconOrFallbackStyle(
       GURL(kDummyUrl),
       14,  // Lowered requirement so stored bitmap is admitted.
       24,
-      base::Bind(&LargeIconServiceTest::ResultCallback, base::Unretained(this)),
+      base::Bind(&LargeIconServiceTest::RawBitmapResultCallback,
+                 base::Unretained(this)),
+      &cancelable_task_tracker_);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(is_callback_invoked_);
+}
+
+TEST_F(LargeIconServiceTest, ImageScaleUp) {
+  InjectMockResult(GURL(kDummyUrl), CreateTestBitmapResult(16, 16, kTestColor));
+  expected_bitmap_ = CreateTestBitmapResult(24, 24, kTestColor);
+  large_icon_service_.GetLargeIconImageOrFallbackStyle(
+      GURL(kDummyUrl),
+      14,  // Lowered requirement so stored bitmap is admitted.
+      24,
+      base::Bind(&LargeIconServiceTest::ImageResultCallback,
+                 base::Unretained(this)),
       &cancelable_task_tracker_);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(is_callback_invoked_);
 }
 
 // |desired_size_in_pixel| == 0 means retrieve original image without scaling.
-TEST_F(LargeIconServiceTest, NoScale) {
+TEST_F(LargeIconServiceTest, RawBitmapNoScale) {
   InjectMockResult(GURL(kDummyUrl), CreateTestBitmapResult(24, 24, kTestColor));
   expected_bitmap_ = CreateTestBitmapResult(24, 24, kTestColor);
   large_icon_service_.GetLargeIconOrFallbackStyle(
       GURL(kDummyUrl), 16, 0,
-      base::Bind(&LargeIconServiceTest::ResultCallback, base::Unretained(this)),
-      &cancelable_task_tracker_);
-  base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(is_callback_invoked_);
-}
-
-TEST_F(LargeIconServiceTest, FallbackSinceIconTooSmall) {
-  InjectMockResult(GURL(kDummyUrl), CreateTestBitmapResult(16, 16, kTestColor));
-  expected_fallback_icon_style_.reset(new favicon_base::FallbackIconStyle);
-  expected_fallback_icon_style_->background_color = kTestColor;
-  expected_fallback_icon_style_->is_default_background_color = false;
-  large_icon_service_.GetLargeIconOrFallbackStyle(
-      GURL(kDummyUrl), 24, 24,
-      base::Bind(&LargeIconServiceTest::ResultCallback, base::Unretained(this)),
-      &cancelable_task_tracker_);
-  base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(is_callback_invoked_);
-}
-
-TEST_F(LargeIconServiceTest, FallbackSinceIconNotSquare) {
+      base::Bind(&LargeIconServiceTest::RawBitmapResultCallback,
+                 base::Unretained(this)),
+      &cancelable_task_tracker_);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(is_callback_invoked_);
+}
+
+// |desired_size_in_pixel| == 0 means retrieve original image without scaling.
+TEST_F(LargeIconServiceTest, ImageNoScale) {
+  InjectMockResult(GURL(kDummyUrl), CreateTestBitmapResult(24, 24, kTestColor));
+  expected_bitmap_ = CreateTestBitmapResult(24, 24, kTestColor);
+  large_icon_service_.GetLargeIconImageOrFallbackStyle(
+      GURL(kDummyUrl), 16, 0,
+      base::Bind(&LargeIconServiceTest::ImageResultCallback,
+                 base::Unretained(this)),
+      &cancelable_task_tracker_);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(is_callback_invoked_);
+}
+
+TEST_F(LargeIconServiceTest, RawBitmapFallbackSinceIconTooSmall) {

[pkotwicz, 2017/04/04 02:34:41]

I don't think that it is worth duplicating the tests for
GetLargeIconOrFallbackStyle() and GetLargeIconImageOrFallbackStyle() where
LargeIconResult and LargeIconImageResult wrap a FallbackIconStyle

If you must, a single FallbackIconStyle test for
GetLargeIconImageOrFallbackStyle() should suffice.

TEST_P() should help reduce the number of new code for duplicated tests

[jkrcal, 2017/04/04 09:34:16]

Okay, I moved the getter tests into a subclass, using TEST_P. I still want to
keep all the tests duplicated, with the TEST_P, I think it makes sense.

+  InjectMockResult(GURL(kDummyUrl), CreateTestBitmapResult(16, 16, kTestColor));
+  expected_fallback_icon_style_.reset(new favicon_base::FallbackIconStyle);
+  expected_fallback_icon_style_->background_color = kTestColor;
+  expected_fallback_icon_style_->is_default_background_color = false;
+  large_icon_service_.GetLargeIconOrFallbackStyle(
+      GURL(kDummyUrl), 24, 24,
+      base::Bind(&LargeIconServiceTest::RawBitmapResultCallback,
+                 base::Unretained(this)),
+      &cancelable_task_tracker_);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(is_callback_invoked_);
+}
+
+TEST_F(LargeIconServiceTest, ImageFallbackSinceIconTooSmall) {
+  InjectMockResult(GURL(kDummyUrl), CreateTestBitmapResult(16, 16, kTestColor));
+  expected_fallback_icon_style_.reset(new favicon_base::FallbackIconStyle);
+  expected_fallback_icon_style_->background_color = kTestColor;
+  expected_fallback_icon_style_->is_default_background_color = false;
+  large_icon_service_.GetLargeIconImageOrFallbackStyle(
+      GURL(kDummyUrl), 24, 24,
+      base::Bind(&LargeIconServiceTest::ImageResultCallback,
+                 base::Unretained(this)),
+      &cancelable_task_tracker_);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(is_callback_invoked_);
+}
+
+TEST_F(LargeIconServiceTest, RawBitmapFallbackSinceIconNotSquare) {
   InjectMockResult(GURL(kDummyUrl), CreateTestBitmapResult(24, 32, kTestColor));
   expected_fallback_icon_style_.reset(new favicon_base::FallbackIconStyle);
   expected_fallback_icon_style_->background_color = kTestColor;
   expected_fallback_icon_style_->is_default_background_color = false;
   large_icon_service_.GetLargeIconOrFallbackStyle(
       GURL(kDummyUrl), 24, 24,
-      base::Bind(&LargeIconServiceTest::ResultCallback, base::Unretained(this)),
-      &cancelable_task_tracker_);
-  base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(is_callback_invoked_);
-}
-
-TEST_F(LargeIconServiceTest, FallbackSinceIconMissing) {
-  InjectMockResult(GURL(kDummyUrl), favicon_base::FaviconRawBitmapResult());
-  // Expect default fallback style, including background.
-  expected_fallback_icon_style_.reset(new favicon_base::FallbackIconStyle);
-  large_icon_service_.GetLargeIconOrFallbackStyle(
-      GURL(kDummyUrl), 24, 24,
-      base::Bind(&LargeIconServiceTest::ResultCallback, base::Unretained(this)),
-      &cancelable_task_tracker_);
-  base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(is_callback_invoked_);
-}
-
-TEST_F(LargeIconServiceTest, FallbackSinceIconMissingNoScale) {
+      base::Bind(&LargeIconServiceTest::RawBitmapResultCallback,
+                 base::Unretained(this)),
+      &cancelable_task_tracker_);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(is_callback_invoked_);
+}
+
+TEST_F(LargeIconServiceTest, ImageFallbackSinceIconNotSquare) {
+  InjectMockResult(GURL(kDummyUrl), CreateTestBitmapResult(24, 32, kTestColor));
+  expected_fallback_icon_style_.reset(new favicon_base::FallbackIconStyle);
+  expected_fallback_icon_style_->background_color = kTestColor;
+  expected_fallback_icon_style_->is_default_background_color = false;
+  large_icon_service_.GetLargeIconImageOrFallbackStyle(
+      GURL(kDummyUrl), 24, 24,
+      base::Bind(&LargeIconServiceTest::ImageResultCallback,
+                 base::Unretained(this)),
+      &cancelable_task_tracker_);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(is_callback_invoked_);
+}
+
+TEST_F(LargeIconServiceTest, RawBitmapFallbackSinceIconMissing) {
+  InjectMockResult(GURL(kDummyUrl), favicon_base::FaviconRawBitmapResult());
+  // Expect default fallback style, including background.
+  expected_fallback_icon_style_.reset(new favicon_base::FallbackIconStyle);
+  large_icon_service_.GetLargeIconOrFallbackStyle(
+      GURL(kDummyUrl), 24, 24,
+      base::Bind(&LargeIconServiceTest::RawBitmapResultCallback,
+                 base::Unretained(this)),
+      &cancelable_task_tracker_);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(is_callback_invoked_);
+}
+
+TEST_F(LargeIconServiceTest, ImageFallbackSinceIconMissing) {
+  InjectMockResult(GURL(kDummyUrl), favicon_base::FaviconRawBitmapResult());
+  // Expect default fallback style, including background.
+  expected_fallback_icon_style_.reset(new favicon_base::FallbackIconStyle);
+  large_icon_service_.GetLargeIconImageOrFallbackStyle(
+      GURL(kDummyUrl), 24, 24,
+      base::Bind(&LargeIconServiceTest::ImageResultCallback,
+                 base::Unretained(this)),
+      &cancelable_task_tracker_);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(is_callback_invoked_);
+}
+
+TEST_F(LargeIconServiceTest, RawBitmapFallbackSinceIconMissingNoScale) {
   InjectMockResult(GURL(kDummyUrl), favicon_base::FaviconRawBitmapResult());
   // Expect default fallback style, including background.
   expected_fallback_icon_style_.reset(new favicon_base::FallbackIconStyle);
   large_icon_service_.GetLargeIconOrFallbackStyle(
       GURL(kDummyUrl), 24, 0,
-      base::Bind(&LargeIconServiceTest::ResultCallback, base::Unretained(this)),
-      &cancelable_task_tracker_);
-  base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(is_callback_invoked_);
+      base::Bind(&LargeIconServiceTest::RawBitmapResultCallback,
+                 base::Unretained(this)),
+      &cancelable_task_tracker_);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(is_callback_invoked_);
+}
+
+TEST_F(LargeIconServiceTest, ImageFallbackSinceIconMissingNoScale) {
+  InjectMockResult(GURL(kDummyUrl), favicon_base::FaviconRawBitmapResult());
+  // Expect default fallback style, including background.
+  expected_fallback_icon_style_.reset(new favicon_base::FallbackIconStyle);
+  large_icon_service_.GetLargeIconImageOrFallbackStyle(
+      GURL(kDummyUrl), 24, 0,
+      base::Bind(&LargeIconServiceTest::ImageResultCallback,
+                 base::Unretained(this)),
+      &cancelable_task_tracker_);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(is_callback_invoked_);
 }
 
 // Oddball case where we demand a high resolution icon to scale down. Generates
 // fallback even though an icon with the final size is available.
-TEST_F(LargeIconServiceTest, FallbackSinceTooPicky) {
+TEST_F(LargeIconServiceTest, RawBitmapFallbackSinceTooPicky) {
   InjectMockResult(GURL(kDummyUrl), CreateTestBitmapResult(24, 24, kTestColor));
   expected_fallback_icon_style_.reset(new favicon_base::FallbackIconStyle);
   expected_fallback_icon_style_->background_color = kTestColor;
   expected_fallback_icon_style_->is_default_background_color = false;
   large_icon_service_.GetLargeIconOrFallbackStyle(
       GURL(kDummyUrl), 32, 24,
-      base::Bind(&LargeIconServiceTest::ResultCallback, base::Unretained(this)),
+      base::Bind(&LargeIconServiceTest::RawBitmapResultCallback,
+                 base::Unretained(this)),
       &cancelable_task_tracker_);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(is_callback_invoked_);
+}
+
+TEST_F(LargeIconServiceTest, ImageFallbackSinceTooPicky) {
+  InjectMockResult(GURL(kDummyUrl), CreateTestBitmapResult(24, 24, kTestColor));
+  expected_fallback_icon_style_.reset(new favicon_base::FallbackIconStyle);
+  expected_fallback_icon_style_->background_color = kTestColor;
+  expected_fallback_icon_style_->is_default_background_color = false;
+  large_icon_service_.GetLargeIconImageOrFallbackStyle(
+      GURL(kDummyUrl), 32, 24,
+      base::Bind(&LargeIconServiceTest::ImageResultCallback,
+                 base::Unretained(this)),
+      &cancelable_task_tracker_);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(is_callback_invoked_);
 }
 
 TEST_F(LargeIconServiceTest, ShouldGetFromGoogleServer) {
   const GURL kExpectedServerUrl(
       "https://t0.gstatic.com/faviconV2?user=chrome&drop_404_icon=true"
       "&size=192&min_size=42&max_size=256&fallback_opts=TYPE"
       "&url=http://www.example.com/");
 
   EXPECT_CALL(mock_favicon_service_, UnableToDownloadFavicon(_)).Times(0);
 
@@ skipping 97 matching lines @@
   large_icon_service_
       .GetLargeIconOrFallbackStyleFromGoogleServerSkippingLocalCache(
           GURL(kDummyUrl), /*min_source_size_in_pixel=*/42, callback.Get());
 
   EXPECT_CALL(callback, Run(false));
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace
 }  // namespace favicon