V1 of material design find in page bar

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"
 #include "base/strings/string_split.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/canvas_image_source.h"
 #include "ui/gfx/vector_icon_types.h"
 #include "ui/gfx/vector_icons2.h"
 
 namespace gfx {
 
 namespace {
 
 // Translates a string such as "MOVE_TO" into a command such as MOVE_TO.
 CommandType CommandFromString(const std::string& source) {
 #define RETURN_IF_IS(command) \
   if (source == #command)     \
     return command;
 
   RETURN_IF_IS(NEW_PATH);

[sky, 2015/08/05 00:06:01]

Don't you need to update this?

[Evan Stade, 2015/08/05 19:04:25]

only if I want it to keep working!

   RETURN_IF_IS(PATH_COLOR_ARGB);
   RETURN_IF_IS(MOVE_TO);
   RETURN_IF_IS(R_MOVE_TO);
   RETURN_IF_IS(LINE_TO);
   RETURN_IF_IS(R_LINE_TO);
   RETURN_IF_IS(H_LINE_TO);
   RETURN_IF_IS(R_H_LINE_TO);
   RETURN_IF_IS(V_LINE_TO);
   RETURN_IF_IS(R_V_LINE_TO);
   RETURN_IF_IS(CUBIC_TO);
@@ skipping 31 matching lines @@
 
   std::vector<SkPath> paths;
   paths.push_back(SkPath());
   paths.back().setFillType(SkPath::kEvenOdd_FillType);
   size_t canvas_size = kReferenceSizeDip;
 
   std::vector<SkPaint> paints;
   paints.push_back(SkPaint());
   paints.back().setColor(color);
 
+  SkRect clip_rect = SkRect::MakeEmpty();
+
   for (size_t i = 0; path_elements[i].type != END; i++) {
     SkPath& path = paths.back();
+    SkPaint& paint = paints.back();
     switch (path_elements[i].type) {
       case NEW_PATH: {
         paths.push_back(SkPath());
         paints.push_back(SkPaint());
         paints.back().setColor(color);
         break;
       }
 
       case PATH_COLOR_ARGB: {
         int a = SkScalarFloorToInt(path_elements[++i].arg);
         int r = SkScalarFloorToInt(path_elements[++i].arg);
         int g = SkScalarFloorToInt(path_elements[++i].arg);
         int b = SkScalarFloorToInt(path_elements[++i].arg);
-        paints.back().setColor(SkColorSetARGB(a, r, g, b));
+        paint.setColor(SkColorSetARGB(a, r, g, b));
         break;
       }
 
+      case STROKE: {
+        paint.setStyle(SkPaint::kStroke_Style);
+        SkScalar width = path_elements[++i].arg;
+        paint.setStrokeWidth(width);
+        break;
+      }
+
       case MOVE_TO: {
         SkScalar x = path_elements[++i].arg;
         SkScalar y = path_elements[++i].arg;
         path.moveTo(x, y);
         break;
       }
 
       case R_MOVE_TO: {
         SkScalar x = path_elements[++i].arg;
         SkScalar y = path_elements[++i].arg;
@@ skipping 77 matching lines @@
         path.close();
         break;
       }
 
       case CANVAS_DIMENSIONS: {
         SkScalar width = path_elements[++i].arg;
         canvas_size = SkScalarTruncToInt(width);
         break;
       }
 
+      case CLIP: {
+        SkScalar x = path_elements[++i].arg;
+        SkScalar y = path_elements[++i].arg;
+        SkScalar w = path_elements[++i].arg;
+        SkScalar h = path_elements[++i].arg;
+        clip_rect = SkRect::MakeXYWH(x, y, w, h);
+        break;
+      }
+
       case END:
         NOTREACHED();
         break;
     }
   }
 
   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) {
-    paints[i].setStyle(SkPaint::kFill_Style);
     paints[i].setAntiAlias(true);
+    paints[i].setStrokeCap(SkPaint::kRound_Cap);
     paths[i].setFillType(SkPath::kEvenOdd_FillType);
     canvas->DrawPath(paths[i], paints[i]);
   }
 }
 
 class VectorIconSource : public CanvasImageSource {
  public:
   VectorIconSource(VectorIconId id, size_t dip_size, SkColor color)
       : CanvasImageSource(
             gfx::Size(static_cast<int>(dip_size), static_cast<int>(dip_size)),
@@ skipping 76 matching lines @@
 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);
-  PaintPath(canvas, GetPathForVectorIcon(id), dip_size, color);
+  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);
 }
 
 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