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>
 #include <cmath>
 #include <cstdlib>
 #include <functional>
 #include <limits>
 #include <memory>
 #include <numeric>
 #include <vector>
 
 #include "skia/ext/platform_canvas.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/canvas.h"
 #include "ui/gfx/color_analysis.h"
 #include "ui/gfx/color_utils.h"
 #include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/image/image.h"
 
 namespace {
 
 #ifndef M_PI
 #define M_PI 3.14159265358979323846
 #endif
 
 unsigned long ImagePixelSum(const SkBitmap& bitmap, const gfx::Rect& rect) {
@@ skipping 83 matching lines @@
   data_sum = ImagePixelSum(reduced_color, echo_rect);
   all_sum = ImagePixelSum(reduced_color, gfx::Rect(800, 600));
   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);
+  gfx::RectF 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));
 
   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);
@@ skipping 16 matching lines @@
   unsigned long all_sum = ImagePixelSum(reduced_color, gfx::Rect(800, 600));
   EXPECT_GT(data_sum, 0U);
   EXPECT_EQ(data_sum, all_sum);
   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::RectF 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));
 
   SkBitmap source = canvas.GetBitmap();
   SkBitmap reduced_color;
   reduced_color.allocPixels(SkImageInfo::MakeA8(source.width(),
                                                 source.height()));
 
   gfx::Vector3dF transform(1, 0, 0);
@@ skipping 44 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::RectF(x, y, fine_print, fine_print), print_color);
     }
   }
 
   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);
+    gfx::RectF pict_rect(x, y, body_rect.width() / 2 - 2 * margin_vertical,

[msw, 2017/04/07 10:12:23]

Should these div ops use floating point literals now? (probably doesn't matter
for this test, just be careful with this and check for implicit and explicit
floor/ceil/round operations in other int->float conversion work).

[Uzair, 2017/04/07 10:53:54]

How about canvas.drawRect(gfx::RectF(pict_rect),..,..) ?

+                         body_rect.height() / 3 - 2 * margin_vertical);
     canvas.FillRect(pict_rect, SkColorSetRGB(255, 255, 255));
     canvas.DrawRect(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