Vectorize website settings icons in omnibox

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 "base/lazy_instance.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 50 matching lines @@
     else
       path.push_back(PathElement(CommandFromString(piece)));
   }
   return path;
 }
 
 void PaintPath(Canvas* canvas,
                const PathElement* path_elements,
                size_t dip_size,
                SkColor color) {
+  canvas->Save();
   SkPath path;
   path.setFillType(SkPath::kEvenOdd_FillType);
 
   size_t canvas_size = kReferenceSizeDip;
   std::vector<SkPath> paths;
   std::vector<SkPaint> paints;
   SkRect clip_rect = SkRect::MakeEmpty();
 
   for (size_t i = 0; path_elements[i].type != END; i++) {
     if (paths.empty() || path_elements[i].type == NEW_PATH) {
@@ skipping 150 matching lines @@
     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, SkColor color)
+  VectorIconSource(VectorIconId id,
+                   size_t dip_size,
+                   SkColor color,
+                   VectorIconId badge_id)
       : CanvasImageSource(
             gfx::Size(static_cast<int>(dip_size), static_cast<int>(dip_size)),
             false),
         id_(id),
-        color_(color) {}
+        color_(color),
+        badge_id_(badge_id) {}
 
   VectorIconSource(const std::string& definition,
                    size_t dip_size,
                    SkColor color)
       : CanvasImageSource(
             gfx::Size(static_cast<int>(dip_size), static_cast<int>(dip_size)),
             false),
         id_(VectorIconId::VECTOR_ICON_NONE),
         path_(PathFromSource(definition)),
-        color_(color) {}
+        color_(color),
+        badge_id_(VectorIconId::VECTOR_ICON_NONE) {}
 
   ~VectorIconSource() override {}
 
   // CanvasImageSource:
   void Draw(gfx::Canvas* canvas) override {
-    if (path_.empty())
+    if (path_.empty()) {
       PaintVectorIcon(canvas, id_, size_.width(), color_);
-    else
+      if (badge_id_ != VectorIconId::VECTOR_ICON_NONE)
+        PaintVectorIcon(canvas, badge_id_, size_.width(), color_);
+    } else {
       PaintPath(canvas, path_.data(), size_.width(), color_);
+    }
   }
 
  private:
   const VectorIconId id_;
   const std::vector<PathElement> path_;
   const SkColor color_;
+  const VectorIconId badge_id_;
 
   DISALLOW_COPY_AND_ASSIGN(VectorIconSource);
 };
 
 // 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, SkColor color) {
-    IconDescription description(id, dip_size, color);
+  ImageSkia GetOrCreateIcon(VectorIconId id,
+                            size_t 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),
+        new VectorIconSource(id, dip_size, color, badge_id),
         gfx::Size(static_cast<int>(dip_size), static_cast<int>(dip_size)));
     images_.insert(std::make_pair(description, icon));
     return icon;
   }
 
  private:
   struct IconDescription {
-    IconDescription(VectorIconId id, size_t dip_size, SkColor color)
-        : id(id), dip_size(dip_size), color(color) {}
+    IconDescription(VectorIconId id,
+                    size_t 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 {
       if (id != other.id)
         return id < other.id;
       if (dip_size != other.dip_size)
         return dip_size < other.dip_size;
-      return color < other.color;
+      if (color != other.color)
+        return color < other.color;
+      return badge_id < 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,
                      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, size_t dip_size, SkColor color) {
-  return g_icon_cache.Get().GetOrCreateIcon(id, dip_size, color);
+  return CreateVectorIconWithBadge(id, dip_size, color,
+                                   VectorIconId::VECTOR_ICON_NONE);
+}
+
+ImageSkia CreateVectorIconWithBadge(VectorIconId id,
+                                    size_t dip_size,
+                                    SkColor color,
+                                    VectorIconId badge_id) {
+  return g_icon_cache.Get().GetOrCreateIcon(id, dip_size, color, badge_id);
 }
 
 ImageSkia CreateVectorIconFromSource(const std::string& source,
                                      size_t dip_size,
                                      SkColor color) {
   return ImageSkia(
       new VectorIconSource(source, dip_size, color),
       gfx::Size(static_cast<int>(dip_size), static_cast<int>(dip_size)));
 }
 
 }  // namespace gfx