Use int rather than size_t to pass DIP amounts to vector icon functions.

ui/gfx/paint_vector_icon.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 "ui/gfx/paint_vector_icon.h"
 
 #include <map>
 #include <tuple>
 
 #include "base/i18n/rtl.h"
@@ skipping 62 matching lines @@
     else if (base::HexStringToInt(piece, &hex_value))
       path.push_back(PathElement(SkIntToScalar(hex_value)));
     else
       path.push_back(PathElement(CommandFromString(piece)));
   }
   return path;
 }
 
 void PaintPath(Canvas* canvas,
                const PathElement* path_elements,
-               size_t dip_size,
+               int dip_size,
                SkColor color) {
   canvas->Save();
   SkPath path;
   path.setFillType(SkPath::kEvenOdd_FillType);
 
-  size_t canvas_size = kReferenceSizeDip;
+  int canvas_size = kReferenceSizeDip;
   std::vector<SkPath> paths;
   std::vector<SkPaint> paints;
   SkRect clip_rect = SkRect::MakeEmpty();
   bool flips_in_rtl = false;
 
   for (size_t i = 0; path_elements[i].type != END; i++) {
     if (paths.empty() || path_elements[i].type == NEW_PATH) {
       paths.push_back(SkPath());
       paths.back().setFillType(SkPath::kEvenOdd_FillType);
 
@@ skipping 188 matching lines @@
       }
 
       case END:
         NOTREACHED();
         break;
     }
   }
 
   if (flips_in_rtl && base::i18n::IsRTL()) {
     canvas->Scale(-1, 1);
-    canvas->Translate(gfx::Vector2d(-static_cast<int>(canvas_size), 0));

[Evan Stade, 2016/08/18 23:25:37]

I don't think this cast is an indication that a negative canvas_size would make
sense. It's an indication that we want to move to the left by the (positive)
canvas_size.

[Peter Kasting, 2016/08/18 23:35:13]

Well, a negative canvas size doesn't make sense in the same way a gfx::Size()
with negative width/height doesn't make sense.  Note that that takes ints as
well.  This is one of those cases where I think the style guide's "don't use an
unsigned type just to document that a value cannot be negative" is in play.

The units involved here are DIP, and while a negative size may not be sensible,
a negative quantity of DIPs is certainly a meaningful thing (here, it means
"move left").  I think the choice of the rest of the codebase to use ints for
DIP and px values is the right one.

[Evan Stade, 2016/08/19 04:21:49]

I didn't know the style guide said that and I still don't know why it says that
(why would we prefer a runtime assertion over a compile time one?)
yea, you're hitting on something that I think is an important distinction. A
count of pixels is different from a vector measured in pixels.

My reading of the style guide doesn't match yours. It says "When appropriate,
you are welcome to use standard types like size_t". When do you think is more
appropriate than when you're describing a quantity that cannot be negative? It
has size in the name so I imagine this kind of thing (canvas_size) must be what
it's intended for. The line about not using unsigned types for non-negative
numbers is in the context of the discussion of unsigned integers like uint32_t.

+    canvas->Translate(gfx::Vector2d(-canvas_size, 0));
   }
 
   if (dip_size != canvas_size) {
     SkScalar scale = SkIntToScalar(dip_size) / SkIntToScalar(canvas_size);
     canvas->sk_canvas()->scale(scale, scale);
   }
 
   if (!clip_rect.isEmpty())
     canvas->sk_canvas()->clipRect(clip_rect);
 
   DCHECK_EQ(paints.size(), paths.size());
   for (size_t i = 0; i < paths.size(); ++i)
     canvas->DrawPath(paths[i], paints[i]);
   canvas->Restore();
 }
 
 class VectorIconSource : public CanvasImageSource {
  public:
   VectorIconSource(VectorIconId id,
-                   size_t dip_size,
+                   int dip_size,
                    SkColor color,
                    VectorIconId badge_id)
-      : CanvasImageSource(
-            gfx::Size(static_cast<int>(dip_size), static_cast<int>(dip_size)),
-            false),
+      : CanvasImageSource(gfx::Size(dip_size, dip_size), false),
         id_(id),
         color_(color),
         badge_id_(badge_id) {}
 
   VectorIconSource(const std::string& definition,
-                   size_t dip_size,
+                   int dip_size,
                    SkColor color)
-      : CanvasImageSource(
-            gfx::Size(static_cast<int>(dip_size), static_cast<int>(dip_size)),
-            false),
+      : CanvasImageSource(gfx::Size(dip_size, dip_size), false),
         id_(VectorIconId::VECTOR_ICON_NONE),
         path_(PathFromSource(definition)),
         color_(color),
         badge_id_(VectorIconId::VECTOR_ICON_NONE) {}
 
   ~VectorIconSource() override {}
 
   // CanvasImageSource:
   bool HasRepresentationAtAllScales() const override {
     return id_ != VectorIconId::VECTOR_ICON_NONE;
@@ skipping 20 matching lines @@
 
 // This class caches vector icons (as ImageSkia) so they don't have to be drawn
 // more than once. This also guarantees the backing data for the images returned
 // by CreateVectorIcon will persist in memory until program termination.
 class VectorIconCache {
  public:
   VectorIconCache() {}
   ~VectorIconCache() {}
 
   ImageSkia GetOrCreateIcon(VectorIconId id,
-                            size_t dip_size,
+                            int dip_size,
                             SkColor color,
                             VectorIconId badge_id) {
     IconDescription description(id, dip_size, color, badge_id);
     auto iter = images_.find(description);
     if (iter != images_.end())
       return iter->second;
 
-    ImageSkia icon(
-        new VectorIconSource(id, dip_size, color, badge_id),
-        gfx::Size(static_cast<int>(dip_size), static_cast<int>(dip_size)));
+    ImageSkia icon(new VectorIconSource(id, dip_size, color, badge_id),
+                   gfx::Size(dip_size, dip_size));
     images_.insert(std::make_pair(description, icon));
     return icon;
   }
 
  private:
   struct IconDescription {
     IconDescription(VectorIconId id,
-                    size_t dip_size,
+                    int dip_size,
                     SkColor color,
                     VectorIconId badge_id)
         : id(id), dip_size(dip_size), color(color), badge_id(badge_id) {}
 
     bool operator<(const IconDescription& other) const {
       return std::tie(id, dip_size, color, badge_id) <
              std::tie(other.id, other.dip_size, other.color, other.badge_id);
     }
 
     VectorIconId id;
     size_t dip_size;
     SkColor color;
     VectorIconId badge_id;
   };
 
   std::map<IconDescription, ImageSkia> images_;
 
   DISALLOW_COPY_AND_ASSIGN(VectorIconCache);
 };
 
 static base::LazyInstance<VectorIconCache> g_icon_cache =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 void PaintVectorIcon(Canvas* canvas,
                      VectorIconId id,
-                     size_t dip_size,
+                     int dip_size,
                      SkColor color) {
   DCHECK(VectorIconId::VECTOR_ICON_NONE != id);
   const PathElement* path = canvas->image_scale() == 1.f
                                 ? GetPathForVectorIconAt1xScale(id)
                                 : GetPathForVectorIcon(id);
   PaintPath(canvas, path, dip_size, color);
 }
 
 ImageSkia CreateVectorIcon(VectorIconId id, SkColor color) {
   const PathElement* one_x_path = GetPathForVectorIconAt1xScale(id);
-  size_t size = one_x_path[0].type == CANVAS_DIMENSIONS ? one_x_path[1].arg
-                                                        : kReferenceSizeDip;
+  int size = (one_x_path[0].type == CANVAS_DIMENSIONS)
+                 ? SkScalarTruncToInt(one_x_path[1].arg)
+                 : kReferenceSizeDip;
   return CreateVectorIcon(id, size, color);
 }
 
-ImageSkia CreateVectorIcon(VectorIconId id, size_t dip_size, SkColor color) {
+ImageSkia CreateVectorIcon(VectorIconId id, int dip_size, SkColor color) {
   return CreateVectorIconWithBadge(id, dip_size, color,
                                    VectorIconId::VECTOR_ICON_NONE);
 }
 
 ImageSkia CreateVectorIconWithBadge(VectorIconId id,
-                                    size_t dip_size,
+                                    int dip_size,
                                     SkColor color,
                                     VectorIconId badge_id) {
   return (id == VectorIconId::VECTOR_ICON_NONE)
              ? gfx::ImageSkia()
              : g_icon_cache.Get().GetOrCreateIcon(id, dip_size, color,
                                                   badge_id);
 }
 
 ImageSkia CreateVectorIconFromSource(const std::string& source,
-                                     size_t dip_size,
+                                     int dip_size,
                                      SkColor color) {
   return ImageSkia(
       new VectorIconSource(source, dip_size, color),
-      gfx::Size(static_cast<int>(dip_size), static_cast<int>(dip_size)));
+      gfx::Size(dip_size, dip_size));
 }
 
 }  // namespace gfx