[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"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/task/cancelable_task_tracker.h"
 #include "base/test/mock_callback.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/favicon/core/favicon_client.h"
 #include "components/favicon/core/test/mock_favicon_service.h"
 #include "components/favicon_base/fallback_icon_style.h"
 #include "components/favicon_base/favicon_types.h"
+#include "components/image_fetcher/core/image_decoder.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 48 matching lines @@
   MOCK_METHOD1(SetImageDownloadLimit,
                void(base::Optional<int64_t> max_download_bytes));
   MOCK_METHOD1(SetDesiredImageFrameSize, void(const gfx::Size& size));
   MOCK_METHOD3(StartOrQueueNetworkRequest,
                void(const std::string&,
                     const GURL&,
                     const ImageFetcherCallback&));
   MOCK_METHOD0(GetImageDecoder, image_fetcher::ImageDecoder*());
 };
 
+class FakeImageDecoder : public image_fetcher::ImageDecoder {
+ public:
+  void DecodeImage(
+      const std::string& image_data,
+      const gfx::Size& desired_image_frame_size,
+      const image_fetcher::ImageDecodedCallback& callback) override {
+    callback.Run(gfx::Image::CreateFrom1xPNGBytes(
+        reinterpret_cast<const unsigned char*>(image_data.data()),
+        image_data.size()));
+  }
+};
+
 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 {
+        is_callback_invoked_(false) {
+    ON_CALL(*mock_image_fetcher_, GetImageDecoder())
+        .WillByDefault(Return(&fake_image_decoder_));
   }
 
-  void ResultCallback(const favicon_base::LargeIconResult& result) {
+  ~LargeIconServiceTest() override {}
+
+  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_;
+  FakeImageDecoder fake_image_decoder_;
   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) {

[jkrcal, 2017/03/30 13:10:46]

I am duplicating most of the tests. I was thinking about parameterized tests for
this but I think it would hurt readability which is not worth for k=2. WDYT?

[pkotwicz, 2017/03/30 19:14:23]

I don't think that duplicating the tests is worth it. Since
GetLargeIconImageOrFallbackStyle() uses GetLargeIconOrFallbackStyle(), in my
opinion you just need to test GetLargeIconOrFallbackStyle()

[jkrcal, 2017/03/31 12:31:11]

In the current version, the new function is not a wrapper anymore, so I think
the tests are worth it, in the end.

   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) {
+  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