Replace SkRect by SkIRect in dark mode module.

As dark mode image classification logic works on integral values,
making APIs accept SkIRect will help callers decide how to round
the SkRects.

This patch rounds |src| and |dst| by calling SkRect::roundOut() in
DarkModeFilterHelper::ApplyToImageIfNeeded().

Bug: 1094005
Change-Id: I86dead7936932e207d0e1a3540de1741c27587d3
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2389862
Commit-Queue: Prashant Nevase <prashant.n@samsung.com>
Reviewed-by: Khushal <khushalsagar@chromium.org>
Reviewed-by: Stephen Chenney <schenney@chromium.org>
Reviewed-by: Philip Rogers <pdr@chromium.org>
Cr-Commit-Position: refs/heads/master@{#810228}

third_party/blink/renderer/platform/graphics/dark_mode_filter.cc

@@ -148,8 +148,8 @@ SkColor DarkModeFilter::InvertColorIfNeeded(SkColor color, ElementRole role) {
 }
 
 DarkModeResult DarkModeFilter::AnalyzeShouldApplyToImage(
-    const SkRect& src,
-    const SkRect& dst) const {
+    const SkIRect& src,
+    const SkIRect& dst) const {
   if (settings().image_policy == DarkModeImagePolicy::kFilterNone)
     return DarkModeResult::kDoNotApplyFilter;
 
@@ -172,8 +172,8 @@ DarkModeResult DarkModeFilter::AnalyzeShouldApplyToImage(
 }
 
 sk_sp<SkColorFilter> DarkModeFilter::ApplyToImage(const SkPixmap& pixmap,
-                                                  const SkRect& src,
-                                                  const SkRect& dst) {
+                                                  const SkIRect& src,
+                                                  const SkIRect& dst) {
   DCHECK(AnalyzeShouldApplyToImage(src, dst) == DarkModeResult::kNotClassified);
   DCHECK(settings().image_policy == DarkModeImagePolicy::kFilterSmart);
   DCHECK(image_filter_);

third_party/blink/renderer/platform/graphics/dark_mode_filter.h

@@ -51,8 +51,8 @@ class PLATFORM_EXPORT DarkModeFilter {
   // get the color filter GetImageFilter() should be called.
   // DarkModeResult::kNotClassified - Dark mode filter should be applied and to
   // get the color filter ApplyToImage() should be called.
-  DarkModeResult AnalyzeShouldApplyToImage(const SkRect& src,
-                                           const SkRect& dst) const;
+  DarkModeResult AnalyzeShouldApplyToImage(const SkIRect& src,
+                                           const SkIRect& dst) const;
 
   // Returns dark mode color filter based on the classification done on
   // |pixmap|. The image cannot be classified if pixmap is empty or |src| is
@@ -61,8 +61,8 @@ class PLATFORM_EXPORT DarkModeFilter {
   // appropriate function call. This function should be called only if image
   // policy is set to DarkModeImagePolicy::kFilterSmart.
   sk_sp<SkColorFilter> ApplyToImage(const SkPixmap& pixmap,
-                                    const SkRect& src,
-                                    const SkRect& dst);
+                                    const SkIRect& src,
+                                    const SkIRect& dst);
 
   // Returns dark mode color filter for images. Before calling this function
   // AnalyzeShouldApplyToImage() must be called for early out or deciding

third_party/blink/renderer/platform/graphics/dark_mode_filter_helper.cc

@@ -27,16 +27,20 @@ void DarkModeFilterHelper::ApplyToImageIfNeeded(
   // this function. See: https://crbug.com/1094781.
   DCHECK(dark_mode_filter->IsDarkModeActive());
 
+  SkIRect rounded_src = src.roundOut();
+  SkIRect rounded_dst = dst.roundOut();
+
   sk_sp<SkColorFilter> filter;
-  DarkModeResult result = dark_mode_filter->AnalyzeShouldApplyToImage(src, dst);
+  DarkModeResult result =
+      dark_mode_filter->AnalyzeShouldApplyToImage(rounded_src, rounded_dst);
 
   if (result == DarkModeResult::kApplyFilter) {
     filter = dark_mode_filter->GetImageFilter();
   } else if (result == DarkModeResult::kNotClassified) {
     DarkModeImageCache* cache = image->GetDarkModeImageCache();
     DCHECK(cache);
-    if (cache->Exists(src)) {
-      filter = cache->Get(src);
+    if (cache->Exists(rounded_src)) {
+      filter = cache->Get(rounded_src);
     } else {
       // Performance warning: Calling this function will synchronously decode
       // image.
@@ -44,8 +48,8 @@ void DarkModeFilterHelper::ApplyToImageIfNeeded(
           image->AsSkBitmapForCurrentFrame(kDoNotRespectImageOrientation);
       SkPixmap pixmap;
       bitmap.peekPixels(&pixmap);
-      filter = dark_mode_filter->ApplyToImage(pixmap, src, dst);
-      cache->Add(src, filter);
+      filter = dark_mode_filter->ApplyToImage(pixmap, rounded_src, rounded_dst);
+      cache->Add(rounded_src, filter);
     }
   }
 

third_party/blink/renderer/platform/graphics/dark_mode_filter_test.cc

@@ -118,38 +118,38 @@ TEST(DarkModeFilterTest, AnalyzeShouldApplyToImage) {
   filter.UpdateSettings(settings);
 
   // |dst| is smaller than threshold size.
-  EXPECT_EQ(filter.AnalyzeShouldApplyToImage(SkRect::MakeWH(100, 100),
-                                             SkRect::MakeWH(100, 100)),
+  EXPECT_EQ(filter.AnalyzeShouldApplyToImage(SkIRect::MakeWH(100, 100),
+                                             SkIRect::MakeWH(100, 100)),
             DarkModeResult::kNotClassified);
 
   // |dst| is smaller than threshold size, even |src| is larger.
-  EXPECT_EQ(filter.AnalyzeShouldApplyToImage(SkRect::MakeWH(200, 200),
-                                             SkRect::MakeWH(100, 100)),
+  EXPECT_EQ(filter.AnalyzeShouldApplyToImage(SkIRect::MakeWH(200, 200),
+                                             SkIRect::MakeWH(100, 100)),
             DarkModeResult::kNotClassified);
 
   // |dst| is smaller than threshold size, |src| is smaller.
-  EXPECT_EQ(filter.AnalyzeShouldApplyToImage(SkRect::MakeWH(20, 20),
-                                             SkRect::MakeWH(100, 100)),
+  EXPECT_EQ(filter.AnalyzeShouldApplyToImage(SkIRect::MakeWH(20, 20),
+                                             SkIRect::MakeWH(100, 100)),
             DarkModeResult::kNotClassified);
 
   // |src| having very smaller width, even |dst| is larger than threshold size.
-  EXPECT_EQ(filter.AnalyzeShouldApplyToImage(SkRect::MakeWH(5, 200),
-                                             SkRect::MakeWH(5, 200)),
+  EXPECT_EQ(filter.AnalyzeShouldApplyToImage(SkIRect::MakeWH(5, 200),
+                                             SkIRect::MakeWH(5, 200)),
             DarkModeResult::kNotClassified);
 
   // |src| having very smaller height, even |dst| is larger than threshold size.
-  EXPECT_EQ(filter.AnalyzeShouldApplyToImage(SkRect::MakeWH(200, 5),
-                                             SkRect::MakeWH(200, 5)),
+  EXPECT_EQ(filter.AnalyzeShouldApplyToImage(SkIRect::MakeWH(200, 5),
+                                             SkIRect::MakeWH(200, 5)),
             DarkModeResult::kNotClassified);
 
   // |dst| is larger than threshold size.
-  EXPECT_EQ(filter.AnalyzeShouldApplyToImage(SkRect::MakeWH(20, 20),
-                                             SkRect::MakeWH(200, 200)),
+  EXPECT_EQ(filter.AnalyzeShouldApplyToImage(SkIRect::MakeWH(20, 20),
+                                             SkIRect::MakeWH(200, 200)),
             DarkModeResult::kDoNotApplyFilter);
 
   // |dst| is larger than threshold size.
-  EXPECT_EQ(filter.AnalyzeShouldApplyToImage(SkRect::MakeWH(20, 200),
-                                             SkRect::MakeWH(20, 200)),
+  EXPECT_EQ(filter.AnalyzeShouldApplyToImage(SkIRect::MakeWH(20, 200),
+                                             SkIRect::MakeWH(20, 200)),
             DarkModeResult::kDoNotApplyFilter);
 }
 

third_party/blink/renderer/platform/graphics/dark_mode_image_cache.h

@@ -20,16 +20,16 @@ class PLATFORM_EXPORT DarkModeImageCache {
   DarkModeImageCache() = default;
   ~DarkModeImageCache() = default;
 
-  bool Exists(const SkRect& src) {
+  bool Exists(const SkIRect& src) {
     return cache_.find(DarkModeKey(src)) != cache_.end();
   }
 
-  sk_sp<SkColorFilter> Get(const SkRect& src) {
+  sk_sp<SkColorFilter> Get(const SkIRect& src) {
     auto result = cache_.find(DarkModeKey(src));
     return (result != cache_.end()) ? result->second : nullptr;
   }
 
-  void Add(const SkRect& src, sk_sp<SkColorFilter> dark_mode_color_filter) {
+  void Add(const SkIRect& src, sk_sp<SkColorFilter> dark_mode_color_filter) {
     DCHECK(!Exists(src));
 
     cache_.emplace(DarkModeKey(src), std::move(dark_mode_color_filter));
@@ -42,14 +42,14 @@ class PLATFORM_EXPORT DarkModeImageCache {
  private:
   struct DarkModeKeyHash;
   struct DarkModeKey {
-    explicit DarkModeKey(SkRect src) : src_(src) {}
+    explicit DarkModeKey(SkIRect src) : src_(src) {}
 
     bool operator==(const DarkModeKey& other) const {
       return src_ == other.src_;
     }
 
    private:
-    SkRect src_;
+    SkIRect src_;
 
     friend struct DarkModeImageCache::DarkModeKeyHash;
   };

third_party/blink/renderer/platform/graphics/dark_mode_image_cache_test.cc

@@ -18,9 +18,9 @@ TEST_F(DarkModeImageCacheTest, Caching) {
   config.fInvertStyle = SkHighContrastConfig::InvertStyle::kInvertLightness;
   sk_sp<SkColorFilter> filter = SkHighContrastFilter::Make(config);
 
-  SkRect src1 = SkRect::MakeXYWH(0, 0, 50, 50);
-  SkRect src2 = SkRect::MakeXYWH(5, 20, 100, 100);
-  SkRect src3 = SkRect::MakeXYWH(6, -9, 50, 50);
+  SkIRect src1 = SkIRect::MakeXYWH(0, 0, 50, 50);
+  SkIRect src2 = SkIRect::MakeXYWH(5, 20, 100, 100);
+  SkIRect src3 = SkIRect::MakeXYWH(6, -9, 50, 50);
 
   EXPECT_FALSE(cache.Exists(src1));
   EXPECT_EQ(cache.Get(src1), nullptr);

third_party/blink/renderer/platform/graphics/dark_mode_image_classifier.cc

@@ -41,7 +41,7 @@ DarkModeImageClassifier::DarkModeImageClassifier() = default;
 DarkModeImageClassifier::~DarkModeImageClassifier() = default;
 
 DarkModeResult DarkModeImageClassifier::Classify(const SkPixmap& pixmap,
-                                                 const SkRect& src) {
+                                                 const SkIRect& src) {
   // Empty pixmap or |src| out of bounds cannot be classified.
   SkIRect bounds = pixmap.bounds();
   if (src.isEmpty() || bounds.isEmpty() || !bounds.contains(src) ||
@@ -57,7 +57,7 @@ DarkModeResult DarkModeImageClassifier::Classify(const SkPixmap& pixmap,
 
 base::Optional<DarkModeImageClassifier::Features>
 DarkModeImageClassifier::GetFeatures(const SkPixmap& pixmap,
-                                     const SkRect& src) {
+                                     const SkIRect& src) {
   DCHECK(!pixmap.bounds().isEmpty());
   float transparency_ratio;
   float background_ratio;
@@ -77,31 +77,17 @@ DarkModeImageClassifier::GetFeatures(const SkPixmap& pixmap,
 // distributed blocks through its width and height, each block is sampled, and
 // checked to see if it seems to be background or foreground.
 void DarkModeImageClassifier::GetSamples(const SkPixmap& pixmap,
-                                         const SkRect& src,
+                                         const SkIRect& src,
                                          std::vector<SkColor>* sampled_pixels,
                                          float* transparency_ratio,
                                          float* background_ratio) {
-  int num_sampled_pixels = kMaxSampledPixels;
-  int num_blocks_x = kMaxBlocks;
-  int num_blocks_y = kMaxBlocks;
-
-  // TODO(prashant.n): Make src as SkIRect for removing flooring and rounding.
-  // Let caller control the rounding.
-  // Crash reports indicate that the src can be less than 1, so make
-  // sure it goes to 1. We know it is not 0 because GetBitmap above
-  // will return false for zero-sized src.
-  IntSize rounded_src(ceil(src.width()), ceil(src.height()));
-
-  if (num_sampled_pixels > rounded_src.Width() * rounded_src.Height())
-    num_sampled_pixels = rounded_src.Width() * rounded_src.Height();
-
-  if (num_blocks_x > rounded_src.Width())
-    num_blocks_x = rounded_src.Width();
-  if (num_blocks_y > rounded_src.Height())
-    num_blocks_y = rounded_src.Height();
+  DCHECK(!src.isEmpty());
 
+  int num_sampled_pixels =
+      std::min(kMaxSampledPixels, src.width() * src.height());
+  int num_blocks_x = std::min(kMaxBlocks, src.width());
+  int num_blocks_y = std::min(kMaxBlocks, src.height());
   int pixels_per_block = num_sampled_pixels / (num_blocks_x * num_blocks_y);
-
   int transparent_pixels = 0;
   int opaque_pixels = 0;
   int blocks_count = 0;
@@ -109,15 +95,16 @@ void DarkModeImageClassifier::GetSamples(const SkPixmap& pixmap,
   std::vector<int> horizontal_grid(num_blocks_x + 1);
   std::vector<int> vertical_grid(num_blocks_y + 1);
 
+  float block_width = static_cast<float>(src.width()) / num_blocks_x;
+  float block_height = static_cast<float>(src.height()) / num_blocks_y;
+
   for (int block = 0; block <= num_blocks_x; block++) {
     horizontal_grid[block] =
-        src.x() + static_cast<int>(round(block * src.width() /
-                                         static_cast<float>(num_blocks_x)));
+        src.x() + static_cast<int>(round(block_width * block));
   }
   for (int block = 0; block <= num_blocks_y; block++) {
     vertical_grid[block] =
-        src.y() + static_cast<int>(round(block * src.height() /
-                                         static_cast<float>(num_blocks_y)));
+        src.y() + static_cast<int>(round(block_height * block));
   }
 
   sampled_pixels->clear();

third_party/blink/renderer/platform/graphics/dark_mode_image_classifier.h

@@ -41,7 +41,7 @@ class PLATFORM_EXPORT DarkModeImageClassifier {
     float background_ratio;
   };
 
-  DarkModeResult Classify(const SkPixmap& pixmap, const SkRect& src);
+  DarkModeResult Classify(const SkPixmap& pixmap, const SkIRect& src);
 
  private:
   DarkModeResult ClassifyWithFeatures(const Features& features);
@@ -50,11 +50,11 @@ class PLATFORM_EXPORT DarkModeImageClassifier {
   enum class ColorMode { kColor = 0, kGrayscale = 1 };
 
   base::Optional<Features> GetFeatures(const SkPixmap& pixmap,
-                                       const SkRect& src);
+                                       const SkIRect& src);
   // Extracts a sample set of pixels (|sampled_pixels|), |transparency_ratio|,
   // and |background_ratio|.
   void GetSamples(const SkPixmap& pixmap,
-                  const SkRect& src,
+                  const SkIRect& src,
                   std::vector<SkColor>* sampled_pixels,
                   float* transparency_ratio,
                   float* background_ratio);

third_party/blink/renderer/platform/graphics/dark_mode_image_classifier_test.cc

@@ -57,7 +57,7 @@ TEST_F(DarkModeImageClassifierTest, ValidImage) {
   bitmap = image->AsSkBitmapForCurrentFrame(kDoNotRespectImageOrientation);
   bitmap.peekPixels(&pixmap);
   EXPECT_EQ(image_classifier()->Classify(
-                pixmap, SkRect::MakeWH(image->width(), image->height())),
+                pixmap, SkIRect::MakeWH(image->width(), image->height())),
             DarkModeResult::kApplyFilter);
 }
 
@@ -67,7 +67,7 @@ TEST_F(DarkModeImageClassifierTest, InvalidImage) {
   SkPixmap pixmap;
 
   // Empty pixmap.
-  SkRect src = SkRect::MakeWH(50, 50);
+  SkIRect src = SkIRect::MakeWH(50, 50);
   EXPECT_EQ(image_classifier()->Classify(pixmap, src),
             DarkModeResult::kDoNotApplyFilter);
 
@@ -77,11 +77,11 @@ TEST_F(DarkModeImageClassifierTest, InvalidImage) {
   bitmap.peekPixels(&pixmap);
   EXPECT_EQ(
       image_classifier()->Classify(
-          pixmap, SkRect::MakeWH(image->width() + 10, image->height() + 10)),
+          pixmap, SkIRect::MakeWH(image->width() + 10, image->height() + 10)),
       DarkModeResult::kDoNotApplyFilter);
 
   // Empty src rect.
-  EXPECT_EQ(image_classifier()->Classify(pixmap, SkRect()),
+  EXPECT_EQ(image_classifier()->Classify(pixmap, SkIRect()),
             DarkModeResult::kDoNotApplyFilter);
 }
 
@@ -94,27 +94,27 @@ TEST_F(DarkModeImageClassifierTest, ImageSpriteAllFragmentsSame) {
   bitmap.peekPixels(&pixmap);
 
   EXPECT_EQ(
-      image_classifier()->Classify(pixmap, SkRect::MakeXYWH(0, 0, 95, 36)),
+      image_classifier()->Classify(pixmap, SkIRect::MakeXYWH(0, 0, 95, 36)),
       DarkModeResult::kApplyFilter);
 
   EXPECT_EQ(
-      image_classifier()->Classify(pixmap, SkRect::MakeXYWH(0, 36, 95, 36)),
+      image_classifier()->Classify(pixmap, SkIRect::MakeXYWH(0, 36, 95, 36)),
       DarkModeResult::kApplyFilter);
 
   EXPECT_EQ(
-      image_classifier()->Classify(pixmap, SkRect::MakeXYWH(0, 72, 95, 36)),
+      image_classifier()->Classify(pixmap, SkIRect::MakeXYWH(0, 72, 95, 36)),
       DarkModeResult::kApplyFilter);
 
   EXPECT_EQ(
-      image_classifier()->Classify(pixmap, SkRect::MakeXYWH(0, 108, 95, 36)),
+      image_classifier()->Classify(pixmap, SkIRect::MakeXYWH(0, 108, 95, 36)),
       DarkModeResult::kApplyFilter);
 
   EXPECT_EQ(
-      image_classifier()->Classify(pixmap, SkRect::MakeXYWH(0, 144, 95, 36)),
+      image_classifier()->Classify(pixmap, SkIRect::MakeXYWH(0, 144, 95, 36)),
       DarkModeResult::kApplyFilter);
 
   EXPECT_EQ(
-      image_classifier()->Classify(pixmap, SkRect::MakeXYWH(0, 180, 95, 36)),
+      image_classifier()->Classify(pixmap, SkIRect::MakeXYWH(0, 180, 95, 36)),
       DarkModeResult::kApplyFilter);
 }
 
@@ -127,27 +127,27 @@ TEST_F(DarkModeImageClassifierTest, ImageSpriteAlternateFragmentsSame) {
   bitmap.peekPixels(&pixmap);
 
   EXPECT_EQ(
-      image_classifier()->Classify(pixmap, SkRect::MakeXYWH(0, 0, 95, 36)),
+      image_classifier()->Classify(pixmap, SkIRect::MakeXYWH(0, 0, 95, 36)),
       DarkModeResult::kApplyFilter);
 
   EXPECT_EQ(
-      image_classifier()->Classify(pixmap, SkRect::MakeXYWH(0, 36, 95, 36)),
+      image_classifier()->Classify(pixmap, SkIRect::MakeXYWH(0, 36, 95, 36)),
       DarkModeResult::kDoNotApplyFilter);
 
   EXPECT_EQ(
-      image_classifier()->Classify(pixmap, SkRect::MakeXYWH(0, 72, 95, 36)),
+      image_classifier()->Classify(pixmap, SkIRect::MakeXYWH(0, 72, 95, 36)),
       DarkModeResult::kApplyFilter);
 
   EXPECT_EQ(
-      image_classifier()->Classify(pixmap, SkRect::MakeXYWH(0, 108, 95, 36)),
+      image_classifier()->Classify(pixmap, SkIRect::MakeXYWH(0, 108, 95, 36)),
       DarkModeResult::kDoNotApplyFilter);
 
   EXPECT_EQ(
-      image_classifier()->Classify(pixmap, SkRect::MakeXYWH(0, 144, 95, 36)),
+      image_classifier()->Classify(pixmap, SkIRect::MakeXYWH(0, 144, 95, 36)),
       DarkModeResult::kApplyFilter);
 
   EXPECT_EQ(
-      image_classifier()->Classify(pixmap, SkRect::MakeXYWH(0, 180, 95, 36)),
+      image_classifier()->Classify(pixmap, SkIRect::MakeXYWH(0, 180, 95, 36)),
       DarkModeResult::kDoNotApplyFilter);
 }
 
@@ -265,10 +265,10 @@ TEST_F(DarkModeImageClassifierTest, FeaturesAndClassification) {
   image = GetImage("/images/resources/grid-large.png");
   bitmap = image->AsSkBitmapForCurrentFrame(kDoNotRespectImageOrientation);
   bitmap.peekPixels(&pixmap);
-  features =
-      image_classifier()
-          ->GetFeatures(pixmap, SkRect::MakeWH(image->width(), image->height()))
-          .value();
+  features = image_classifier()
+                 ->GetFeatures(pixmap,
+                               SkIRect::MakeWH(image->width(), image->height()))
+                 .value();
   EXPECT_EQ(image_classifier()->ClassifyWithFeatures(features),
             DarkModeResult::kApplyFilter);
   EXPECT_EQ(image_classifier()->ClassifyUsingDecisionTree(features),
@@ -286,10 +286,10 @@ TEST_F(DarkModeImageClassifierTest, FeaturesAndClassification) {
   image = GetImage("/images/resources/apng08-ref.png");
   bitmap = image->AsSkBitmapForCurrentFrame(kDoNotRespectImageOrientation);
   bitmap.peekPixels(&pixmap);
-  features =
-      image_classifier()
-          ->GetFeatures(pixmap, SkRect::MakeWH(image->width(), image->height()))
-          .value();
+  features = image_classifier()
+                 ->GetFeatures(pixmap,
+                               SkIRect::MakeWH(image->width(), image->height()))
+                 .value();
   EXPECT_EQ(image_classifier()->ClassifyWithFeatures(features),
             DarkModeResult::kDoNotApplyFilter);
   EXPECT_EQ(image_classifier()->ClassifyUsingDecisionTree(features),
@@ -307,10 +307,10 @@ TEST_F(DarkModeImageClassifierTest, FeaturesAndClassification) {
   image = GetImage("/images/resources/twitter_favicon.ico");
   bitmap = image->AsSkBitmapForCurrentFrame(kDoNotRespectImageOrientation);
   bitmap.peekPixels(&pixmap);
-  features =
-      image_classifier()
-          ->GetFeatures(pixmap, SkRect::MakeWH(image->width(), image->height()))
-          .value();
+  features = image_classifier()
+                 ->GetFeatures(pixmap,
+                               SkIRect::MakeWH(image->width(), image->height()))
+                 .value();
   EXPECT_EQ(image_classifier()->ClassifyWithFeatures(features),
             DarkModeResult::kApplyFilter);
   EXPECT_EQ(image_classifier()->ClassifyUsingDecisionTree(features),
@@ -328,10 +328,10 @@ TEST_F(DarkModeImageClassifierTest, FeaturesAndClassification) {
   image = GetImage("/images/resources/blue-wheel-srgb-color-profile.png");
   bitmap = image->AsSkBitmapForCurrentFrame(kDoNotRespectImageOrientation);
   bitmap.peekPixels(&pixmap);
-  features =
-      image_classifier()
-          ->GetFeatures(pixmap, SkRect::MakeWH(image->width(), image->height()))
-          .value();
+  features = image_classifier()
+                 ->GetFeatures(pixmap,
+                               SkIRect::MakeWH(image->width(), image->height()))
+                 .value();
   EXPECT_EQ(image_classifier()->ClassifyWithFeatures(features),
             DarkModeResult::kDoNotApplyFilter);
   EXPECT_EQ(image_classifier()->ClassifyUsingDecisionTree(features),
@@ -349,10 +349,10 @@ TEST_F(DarkModeImageClassifierTest, FeaturesAndClassification) {
   image = GetImage("/images/resources/ycbcr-444-float.jpg");
   bitmap = image->AsSkBitmapForCurrentFrame(kDoNotRespectImageOrientation);
   bitmap.peekPixels(&pixmap);
-  features =
-      image_classifier()
-          ->GetFeatures(pixmap, SkRect::MakeWH(image->width(), image->height()))
-          .value();
+  features = image_classifier()
+                 ->GetFeatures(pixmap,
+                               SkIRect::MakeWH(image->width(), image->height()))
+                 .value();
   EXPECT_EQ(image_classifier()->ClassifyWithFeatures(features),
             DarkModeResult::kApplyFilter);
   EXPECT_EQ(image_classifier()->ClassifyUsingDecisionTree(features),