Remove deprecated functions from Canvas in favor of the RectF version.

chrome/browser/thumbnails/content_analysis_unittest.cc

 // Copyright (c) 2012 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 "chrome/browser/thumbnails/content_analysis.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 111 matching lines @@
   EXPECT_GT(data_sum, 0U);
   EXPECT_EQ(data_sum, all_sum);
 }
 
 TEST_F(ThumbnailContentAnalysisTest, ApplyGradientMagnitudeOnFrame) {
   gfx::Canvas canvas(gfx::Size(800, 600), 1.0f, true);
 
   // The image consists of a single white block in the centre.
   gfx::Rect draw_rect(300, 200, 200, 200);
   canvas.FillRect(gfx::Rect(0, 0, 800, 600), SkColorSetRGB(0, 0, 0));
-  canvas.DrawRect(draw_rect, SkColorSetRGB(255, 255, 255));
+  canvas.DrawRect(gfx::RectF(draw_rect), SkColorSetRGB(255, 255, 255));

[Matt Giuca, 2017/04/07 06:38:08]

Don't cast the Rect to a RectF. Just change the type of the |draw_rect| variable
to RectF.

Also you need to #include "ui/gfx/geometry/rect_f.h"

[Uzair, 2017/04/07 08:50:15]

Done.

 
   SkBitmap source = canvas.GetBitmap();
 
   SkBitmap reduced_color;
   reduced_color.allocPixels(SkImageInfo::MakeA8(source.width(),
                                                 source.height()));
 
   gfx::Vector3dF transform(0.299f, 0.587f, 0.114f);
   EXPECT_TRUE(color_utils::ApplyColorReduction(
       source, transform, true, &reduced_color));
@@ skipping 17 matching lines @@
   EXPECT_EQ(ImagePixelSum(reduced_color, inner_rect), 0U);
 }
 
 TEST_F(ThumbnailContentAnalysisTest, ExtractImageProfileInformation) {
   gfx::Canvas canvas(gfx::Size(800, 600), 1.0f, true);
 
   // The image consists of a white frame drawn in the centre.
   gfx::Rect draw_rect(100, 100, 200, 100);
   gfx::Rect image_rect(0, 0, 800, 600);
   canvas.FillRect(image_rect, SkColorSetRGB(0, 0, 0));
-  canvas.DrawRect(draw_rect, SkColorSetRGB(255, 255, 255));
+  canvas.DrawRect(gfx::RectF(draw_rect), SkColorSetRGB(255, 255, 255));
 
   SkBitmap source = canvas.GetBitmap();
   SkBitmap reduced_color;
   reduced_color.allocPixels(SkImageInfo::MakeA8(source.width(),
                                                 source.height()));
 
   gfx::Vector3dF transform(1, 0, 0);
   EXPECT_TRUE(color_utils::ApplyColorReduction(
       source, transform, true, &reduced_color));
   std::vector<float> column_profile;
@@ skipping 41 matching lines @@
 }
 
 TEST_F(ThumbnailContentAnalysisTest,
        ExtractImageProfileInformationWithClosing) {
   gfx::Canvas canvas(gfx::Size(800, 600), 1.0f, true);
 
   // The image consists of a two white frames drawn side by side, with a
   // single-pixel vertical gap in between.
   gfx::Rect image_rect(0, 0, 800, 600);
   canvas.FillRect(image_rect, SkColorSetRGB(0, 0, 0));
-  canvas.DrawRect(gfx::Rect(300, 250, 99, 100), SkColorSetRGB(255, 255, 255));
-  canvas.DrawRect(gfx::Rect(401, 250, 99, 100), SkColorSetRGB(255, 255, 255));
+  canvas.DrawRect(gfx::RectF(300, 250, 99, 100), SkColorSetRGB(255, 255, 255));
+  canvas.DrawRect(gfx::RectF(401, 250, 99, 100), SkColorSetRGB(255, 255, 255));
 
   SkBitmap source = canvas.GetBitmap();
   SkBitmap reduced_color;
   reduced_color.allocPixels(SkImageInfo::MakeA8(source.width(),
                                                 source.height()));
 
   gfx::Vector3dF transform(1, 0, 0);
   EXPECT_TRUE(color_utils::ApplyColorReduction(
       source, transform, true, &reduced_color));
   std::vector<float> column_profile;
@@ skipping 370 matching lines @@
 
   // 'Fine print' at the bottom.
   const int fine_print = 8;
   const SkColor print_color = SkColorSetRGB(45, 30, 30);
   for (int y = footer_rect.y() + fine_print;
        y < footer_rect.bottom() - fine_print;
        y += 2 * fine_print) {
     for (int x = footer_rect.x() + fine_print;
          x < footer_rect.right() - fine_print;
          x += 2 * fine_print) {
-      canvas.DrawRect(gfx::Rect(x, y, fine_print, fine_print),  print_color);
+      canvas.DrawRect(gfx::RectF(x, y, fine_print, fine_print), print_color);
     }
   }
 
   // Blocky content at the top.
   const int block_size = header_rect.height() - margin_vertical;
   for (int x = header_rect.x() + margin_horizontal;
        x < header_rect.right() - block_size;
        x += block_size + margin_horizontal) {
     const int half_block = block_size / 2 - 5;
     const SkColor block_color = SkColorSetRGB(255, 255, 255);
     const int y = header_rect.y() + margin_vertical / 2;
     int second_col = x + half_block + 10;
     int second_row = y + half_block + 10;
     canvas.FillRect(gfx::Rect(x, y, half_block, block_size), block_color);
     canvas.FillRect(gfx::Rect(second_col,  y, half_block, half_block),
                     block_color);
     canvas.FillRect(gfx::Rect(second_col, second_row, half_block, half_block),
                     block_color);
   }
 
   // Now the main body. Mostly text with some 'pictures'.
   for (int y = body_rect.y() + fine_print;
        y < body_rect.bottom() - fine_print;
        y += 2 * fine_print) {
     for (int x = body_rect.x() + fine_print;
          x < body_rect.right() - fine_print;
          x += 2 * fine_print) {
-      canvas.DrawRect(gfx::Rect(x, y, fine_print, fine_print),  print_color);
+      canvas.DrawRect(gfx::RecFt(x, y, fine_print, fine_print), print_color);

[Matt Giuca, 2017/04/07 06:38:08]

RectF

[Uzair, 2017/04/07 08:50:15]

Apologies for the mistake.

     }
   }
 
   for (int line = 0; line < 3; ++line) {
     int alignment = line % 2;
     const int y = body_rect.y() +
         body_rect.height() / 3 * line + margin_vertical;
     const int x = body_rect.x() +
         alignment * body_rect.width() / 2 + margin_vertical;
     gfx::Rect pict_rect(x, y,
                         body_rect.width() / 2 - 2 * margin_vertical,
                         body_rect.height() / 3 - 2 * margin_vertical);
     canvas.FillRect(pict_rect, SkColorSetRGB(255, 255, 255));
-    canvas.DrawRect(pict_rect, SkColorSetRGB(0, 0, 0));
+    canvas.DrawRect(gfx::RectF(pict_rect), SkColorSetRGB(0, 0, 0));
   }
 
   SkBitmap source = canvas.GetBitmap();
 
   SkBitmap result = CreateRetargetedThumbnailImage(
       source, gfx::Size(424, 264), 2.5);
   EXPECT_FALSE(result.empty());
 
   // Given the nature of computation We can't really assert much here about the
   // image itself. We know it should have been computed, should be smaller than
   // the original and it must not be zero.
   EXPECT_LT(result.width(), image_size.width());
   EXPECT_LT(result.height(), image_size.height());
 
   int histogram[256] = {};
   color_utils::BuildLumaHistogram(result, histogram);
   int non_zero_color_count = std::count_if(
       histogram, histogram + 256, [](int value) { return value > 0; });
   EXPECT_GT(non_zero_color_count, 4);
 
 }
 
 }  // namespace thumbnailing_utils