Add support for CUBIC_TO_S for rendering vector icons

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 30 matching lines @@
   RETURN_IF_IS(ARC_TO);
   RETURN_IF_IS(R_ARC_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);
   RETURN_IF_IS(R_CUBIC_TO);
+  RETURN_IF_IS(CUBIC_TO_SHORTHAND);
   RETURN_IF_IS(CIRCLE);
   RETURN_IF_IS(ROUND_RECT);
   RETURN_IF_IS(CLOSE);
   RETURN_IF_IS(CANVAS_DIMENSIONS);
   RETURN_IF_IS(CLIP);
   RETURN_IF_IS(DISABLE_AA);
   RETURN_IF_IS(FLIPS_IN_RTL);
   RETURN_IF_IS(END);
 #undef RETURN_IF_IS
 
@@ skipping 23 matching lines @@
                int dip_size,
                SkColor color) {
   SkPath path;
   path.setFillType(SkPath::kEvenOdd_FillType);
 
   int canvas_size = kReferenceSizeDip;
   std::vector<SkPath> paths;
   std::vector<SkPaint> paints;
   SkRect clip_rect = SkRect::MakeEmpty();
   bool flips_in_rtl = false;
+  CommandType previous_command_type = NEW_PATH;
 
   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);
 
       paints.push_back(SkPaint());
       paints.back().setColor(color);
       paints.back().setAntiAlias(true);
       paints.back().setStrokeCap(SkPaint::kRound_Cap);
@@ skipping 128 matching lines @@
         SkScalar x1 = path_elements[++i].arg;
         SkScalar y1 = path_elements[++i].arg;
         SkScalar x2 = path_elements[++i].arg;
         SkScalar y2 = path_elements[++i].arg;
         SkScalar x3 = path_elements[++i].arg;
         SkScalar y3 = path_elements[++i].arg;
         path.rCubicTo(x1, y1, x2, y2, x3, y3);
         break;
       }
 
+      case CUBIC_TO_SHORTHAND: {
+        // Compute the first control point (|x1| and |y1|) as the reflection
+        // of the second control point on the previous command relative to
+        // the current point. If there is no previous command or if the
+        // previous command is not a cubic Bezier curve, the first control
+        // point is coincident with the current point. Refer to the SVG
+        // path specs for further details.
+        SkPoint last_point;
+        path.getLastPt(&last_point);
+        SkScalar delta_x = 0;
+        SkScalar delta_y = 0;
+        if (previous_command_type == CUBIC_TO ||

[Evan Stade, 2016/09/07 16:34:22]

it seems there's no easy way to get the last verb out of the SkPath, which is
too bad, because if (path.getLastVerb() == SkPath::kCubic_Verb) would be slick.

+            previous_command_type == R_CUBIC_TO ||
+            previous_command_type == CUBIC_TO_SHORTHAND) {
+          SkPoint last_control_point = path.getPoint(path.countPoints() - 2);
+          delta_x = last_point.fX - last_control_point.fX;
+          delta_y = last_point.fY - last_control_point.fY;
+        }
+
+        SkScalar x1 = last_point.fX + delta_x;
+        SkScalar y1 = last_point.fY + delta_y;
+        SkScalar x2 = path_elements[++i].arg;
+        SkScalar y2 = path_elements[++i].arg;
+        SkScalar x3 = path_elements[++i].arg;
+        SkScalar y3 = path_elements[++i].arg;
+        path.cubicTo(x1, y1, x2, y2, x3, y3);
+        break;
+      }
+
       case CIRCLE: {
         SkScalar x = path_elements[++i].arg;
         SkScalar y = path_elements[++i].arg;
         SkScalar r = path_elements[++i].arg;
         path.addCircle(x, y, r);
         break;
       }
 
       case ROUND_RECT: {
         SkScalar x = path_elements[++i].arg;
@@ skipping 32 matching lines @@
 
       case FLIPS_IN_RTL: {
         flips_in_rtl = true;
         break;
       }
 
       case END:
         NOTREACHED();
         break;
     }
+
+    previous_command_type = command_type;
   }
 
   gfx::ScopedRTLFlipCanvas scoped_rtl_flip_canvas(canvas, canvas_size,
                                                   flips_in_rtl);
 
   if (dip_size != canvas_size) {
     SkScalar scale = SkIntToScalar(dip_size) / SkIntToScalar(canvas_size);
     canvas->sk_canvas()->scale(scale, scale);
   }
 
@@ skipping 257 matching lines @@
 }
 
 ImageSkia CreateVectorIconFromSource(const std::string& source,
                                      int dip_size,
                                      SkColor color) {
   return ImageSkia(new VectorIconSourceLegacy(source, dip_size, color),
                    gfx::Size(dip_size, dip_size));
 }
 
 }  // namespace gfx