Add support for animations in 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"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "cc/paint/paint_canvas.h"
 #include "cc/paint/paint_flags.h"
 #include "third_party/skia/include/core/SkPath.h"
+#include "ui/gfx/animation/tween.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/canvas_image_source.h"
 #include "ui/gfx/scoped_canvas.h"
 #include "ui/gfx/vector_icon_types.h"
 
 namespace gfx {
 
 namespace {
 
 // Helper that simplifies iterating over a sequence of PathElements.
@@ skipping 25 matching lines @@
       case CANVAS_DIMENSIONS:
         return 1;
 
       case MOVE_TO:
       case R_MOVE_TO:
       case LINE_TO:
       case R_LINE_TO:
         return 2;
 
       case CIRCLE:
+      case TRANSITION_END:
         return 3;
 
       case PATH_COLOR_ARGB:
       case CUBIC_TO_SHORTHAND:
       case CLIP:
         return 4;
 
       case ROUND_RECT:
         return 5;
 
       case CUBIC_TO:
       case R_CUBIC_TO:
         return 6;
 
       case ARC_TO:
       case R_ARC_TO:
         return 7;
 
       case NEW_PATH:
       case PATH_MODE_CLEAR:
       case CAP_SQUARE:
       case CLOSE:
       case DISABLE_AA:
       case FLIPS_IN_RTL:
+      case TRANSITION_FROM:
+      case TRANSITION_TO:
       case END:
         return 0;
     }
 
     NOTREACHED();
     return 0;
   }
 
   const PathElement* path_elements_;
   int command_index_ = 0;
@@ skipping 52 matching lines @@
       path.push_back(PathElement(SkIntToScalar(hex_value)));
     else
       path.push_back(PathElement(CommandFromString(piece)));
   }
   return path;
 }
 
 void PaintPath(Canvas* canvas,
                const PathElement* path_elements,
                int dip_size,
-               SkColor color) {
+               SkColor color,
+               const base::TimeDelta* elapsed_time = nullptr) {
   SkPath path;
   path.setFillType(SkPath::kEvenOdd_FillType);
 
   int canvas_size = kReferenceSizeDip;
   std::vector<SkPath> paths;
   std::vector<cc::PaintFlags> flags_array;
   SkRect clip_rect = SkRect::MakeEmpty();
   bool flips_in_rtl = false;
   CommandType previous_command_type = NEW_PATH;
 
   for (PathParser parser(path_elements); parser.CurrentCommand() != END;
        parser.Advance()) {
     auto arg = [&parser](int i) { return parser.GetArgument(i); };
     const CommandType command_type = parser.CurrentCommand();
-    if (paths.empty() || command_type == NEW_PATH) {
+
+    auto start_new_path = [&paths]() {
       paths.push_back(SkPath());
       paths.back().setFillType(SkPath::kEvenOdd_FillType);
-
+    };
+    auto start_new_flags = [&flags_array, &color]() {
       flags_array.push_back(cc::PaintFlags());
       flags_array.back().setColor(color);
       flags_array.back().setAntiAlias(true);
       flags_array.back().setStrokeCap(cc::PaintFlags::kRound_Cap);
+    };
+
+    if (paths.empty() || command_type == NEW_PATH) {
+      start_new_path();
+      start_new_flags();
     }
 
     SkPath& path = paths.back();
     cc::PaintFlags& flags = flags_array.back();
     switch (command_type) {
       // Handled above.
       case NEW_PATH:
         break;
 
       case PATH_COLOR_ARGB:
@@ skipping 139 matching lines @@
         break;
 
       case DISABLE_AA:
         flags.setAntiAlias(false);
         break;
 
       case FLIPS_IN_RTL:
         flips_in_rtl = true;
         break;
 
+      // Transitions work by pushing new paths and a new set of flags onto the
+      // stack. When TRANSITION_END is seen, the paths and flags are
+      // interpolated based on |elapsed_time| and the tween type.
+      case TRANSITION_FROM: {
+        start_new_path();

[tdanderson, 2017/05/09 20:31:40]

I think you want to push a copy of flags_array.back() onto |flags_array| here,
then perform an extra flags_array.pop_back() after line 412. Consider:

<A>
TRANSITION_FROM
<B>
TRANSITION_TO
<C>
TRANSITION_END
<D>

As currently implemented, any changes to PaintFlags properties within <A> can be
overwritten within <B>, and these changes will persist once <D> is reached. It
seems we'd instead want to have <D> use only the PaintFlags properties specified
within <A>.

[Evan Stade, 2017/05/09 21:25:04]

The current implementation is correct. For pathing commands, the things in <B>
and <C> have to be similar enough to be interpolatable (i.e. only differ in
their arguments), but there's no such restriction for the non-pathing commands
like color, AA, etc. 

<D> is not something that comes after the end of the transition. Both <A> and
<D> in your example are things that hold true for any |elapsed_time|. (It
doesn't make sense to specify the same property in both <A> and <D>, but that is
nothing new; it already didn't make sense to use PATH_COLOR_ARGB twice in a
row.) <B> is something that's true before |delay| and <C> is something that's
true only after |delay|. Therefore we can just write <B> on top of the active
flags and then blend <C> onto that depending on |elapsed_time|.

[tdanderson, 2017/05/09 21:54:18]

This makes sense, thank you for the clear explanation. Mental model corrected
accordingly.

+        break;
+      }
+
+      case TRANSITION_TO: {
+        start_new_path();
+        start_new_flags();
+        break;
+      }
+
+      case TRANSITION_END: {
+        DCHECK_GT(paths.size(), 2U);
+
+        const base::TimeDelta delay =
+            base::TimeDelta::FromMillisecondsD(SkScalarToDouble(arg(0)));
+        const base::TimeDelta duration =
+            base::TimeDelta::FromMillisecondsD(SkScalarToDouble(arg(1)));
+        const base::TimeDelta current_time =
+            elapsed_time ? *elapsed_time : base::TimeDelta();
+
+        double state = 0;
+        if (current_time >= delay + duration) {
+          state = 1;
+        } else if (current_time > delay) {
+          state = (current_time - delay).ToInternalValue() /
+                  static_cast<double>(duration.ToInternalValue());
+        }
+
+        auto weight =
+            Tween::CalculateValue(static_cast<Tween::Type>(arg(2)), state);
+
+        SkPath path1, path2;
+        path1.swap(paths.back());
+        paths.pop_back();
+        path2.swap(paths.back());
+        paths.pop_back();
+
+        SkPath interpolated_path;
+        bool could_interpolate =
+            path1.interpolate(path2, weight, &interpolated_path);
+        DCHECK(could_interpolate);
+        paths.back().addPath(interpolated_path);
+
+        // Perform manual interpolation of flags properties. TODO(estade): fill
+        // more of these in as necessary.
+        DCHECK_GT(flags_array.size(), 1U);
+        cc::PaintFlags& end_flags = flags_array.back();
+        cc::PaintFlags& start_flags = flags_array[flags_array.size() - 2];
+
+        start_flags.setColor(Tween::ColorValueBetween(
+            weight, start_flags.getColor(), end_flags.getColor()));
+        start_flags.setStrokeWidth(Tween::FloatValueBetween(
+            weight, start_flags.getStrokeWidth(), end_flags.getStrokeWidth()));
+
+        flags_array.pop_back();
+        break;
+      }
+
       case END:
         NOTREACHED();
         break;
     }
 
     previous_command_type = command_type;
   }
 
-  gfx::ScopedRTLFlipCanvas scoped_rtl_flip_canvas(canvas, canvas_size,
-                                                  flips_in_rtl);
+  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);
   }
 
   if (!clip_rect.isEmpty())
     canvas->sk_canvas()->clipRect(clip_rect);
 
   DCHECK_EQ(flags_array.size(), paths.size());
   for (size_t i = 0; i < paths.size(); ++i)
     canvas->DrawPath(paths[i], flags_array[i]);
 }
 
 class VectorIconSource : public CanvasImageSource {
  public:
   VectorIconSource(const VectorIcon& icon,
                    int dip_size,
                    SkColor color,
                    const VectorIcon& badge_icon)
-      : CanvasImageSource(gfx::Size(dip_size, dip_size), false),
+      : CanvasImageSource(Size(dip_size, dip_size), false),
         color_(color),
         icon_(icon),
         badge_(badge_icon) {}
 
   VectorIconSource(const std::string& definition, int dip_size, SkColor color)
-      : CanvasImageSource(gfx::Size(dip_size, dip_size), false),
+      : CanvasImageSource(Size(dip_size, dip_size), false),
         color_(color),
         icon_(kNoneIcon),
         badge_(kNoneIcon),
         path_(PathFromSource(definition)) {}
 
   ~VectorIconSource() override {}
 
   // CanvasImageSource:
   bool HasRepresentationAtAllScales() const override {
     return !icon_.is_empty();
   }
 
-  void Draw(gfx::Canvas* canvas) override {
+  void Draw(Canvas* canvas) override {
     if (path_.empty()) {
       PaintVectorIcon(canvas, icon_, size_.width(), color_);
       if (!badge_.is_empty())
         PaintVectorIcon(canvas, badge_, size_.width(), color_);
     } else {
       PaintPath(canvas, path_.data(), size_.width(), color_);
     }
   }
 
  private:
@@ skipping 17 matching lines @@
                             int dip_size,
                             SkColor color,
                             const VectorIcon& badge_icon) {
     IconDescription description(&icon, dip_size, color, &badge_icon);
     auto iter = images_.find(description);
     if (iter != images_.end())
       return iter->second;
 
     ImageSkia icon_image(
         new VectorIconSource(icon, dip_size, color, badge_icon),
-        gfx::Size(dip_size, dip_size));
+        Size(dip_size, dip_size));
     images_.insert(std::make_pair(description, icon_image));
     return icon_image;
   }
 
  private:
   struct IconDescription {
     IconDescription(const VectorIcon* icon,
                     int dip_size,
                     SkColor color,
                     const VectorIcon* badge_icon)
         : icon(icon),
           dip_size(dip_size),
           color(color),
           badge_icon(badge_icon) {}
 
     bool operator<(const IconDescription& other) const {
       return std::tie(icon, dip_size, color, badge_icon) <
              std::tie(other.icon, other.dip_size, other.color,
                       other.badge_icon);
     }
 
-    const gfx::VectorIcon* icon;
+    const VectorIcon* icon;
     int dip_size;
     SkColor color;
-    const gfx::VectorIcon* badge_icon;
+    const VectorIcon* badge_icon;
   };
 
   std::map<IconDescription, ImageSkia> images_;
 
   DISALLOW_COPY_AND_ASSIGN(VectorIconCache);
 };
 
 static base::LazyInstance<VectorIconCache>::DestructorAtExit g_icon_cache =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 const VectorIcon kNoneIcon = {};
 
-void PaintVectorIcon(Canvas* canvas, const VectorIcon& icon, SkColor color) {
-  PaintVectorIcon(canvas, icon, GetDefaultSizeOfVectorIcon(icon), color);
+void PaintVectorIcon(Canvas* canvas,
+                     const VectorIcon& icon,
+                     SkColor color,
+                     const base::TimeDelta* elapsed_time) {
+  PaintVectorIcon(canvas, icon, GetDefaultSizeOfVectorIcon(icon), color,
+                  elapsed_time);
 }
 
 void PaintVectorIcon(Canvas* canvas,
                      const VectorIcon& icon,
                      int dip_size,
-                     SkColor color) {
+                     SkColor color,
+                     const base::TimeDelta* elapsed_time) {
   DCHECK(!icon.is_empty());
   const PathElement* path = (canvas->image_scale() == 1.f && icon.path_1x_)
                                 ? icon.path_1x_
                                 : icon.path_;
-  PaintPath(canvas, path, dip_size, color);
+  PaintPath(canvas, path, dip_size, color, elapsed_time);
 }
 
 ImageSkia CreateVectorIcon(const VectorIcon& icon, SkColor color) {
   return CreateVectorIcon(icon, GetDefaultSizeOfVectorIcon(icon), color);
 }
 
 ImageSkia CreateVectorIcon(const VectorIcon& icon,
                            int dip_size,
                            SkColor color) {
   return CreateVectorIconWithBadge(icon, dip_size, color, kNoneIcon);
 }
 
 ImageSkia CreateVectorIconWithBadge(const VectorIcon& icon,
                                     int dip_size,
                                     SkColor color,
                                     const VectorIcon& badge_icon) {
-  return icon.is_empty() ? gfx::ImageSkia()
+  return icon.is_empty() ? ImageSkia()
                          : g_icon_cache.Get().GetOrCreateIcon(
                                icon, dip_size, color, badge_icon);
 }
 
 ImageSkia CreateVectorIconFromSource(const std::string& source,
                                      int dip_size,
                                      SkColor color) {
   return CanvasImageSource::MakeImageSkia<VectorIconSource>(source, dip_size,
                                                             color);
 }
 
-int GetDefaultSizeOfVectorIcon(const gfx::VectorIcon& icon) {
+int GetDefaultSizeOfVectorIcon(const VectorIcon& icon) {
   const PathElement* one_x_path = icon.path_1x_ ? icon.path_1x_ : icon.path_;
   return one_x_path[0].command == CANVAS_DIMENSIONS ? one_x_path[1].arg
                                                     : kReferenceSizeDip;
 }
 
+base::TimeDelta GetDurationOfAnimation(const VectorIcon& icon) {
+  base::TimeDelta last_motion;
+  PathParser parser(icon.path_);
+  while (parser.Advance()) {

[tdanderson, 2017/05/09 20:31:40]

You will need to change this condition since Advance() no longer returns a bool.

[Evan Stade, 2017/05/09 22:45:14]

Done.

+    if (parser.CurrentCommand() != TRANSITION_END)
+      continue;
+
+    auto end_time = base::TimeDelta::FromMillisecondsD(parser.GetArgument(0)) +
+                    base::TimeDelta::FromMillisecondsD(parser.GetArgument(1));
+    if (end_time > last_motion)
+      last_motion = end_time;
+  }
+  return last_motion;

[sadrul, 2017/05/09 22:12:03]

Can this be cached in VectorIcon? e.g. Optional<base::TimeDelta>
animation_duration_? Having to parse for each call to this doesn't sound great.

[Evan Stade, 2017/05/09 22:45:14]

It will be cached by the call site. I suppose I could create a static map in
this file similar to what VectorIconCache does, but for animated icons we're
going to be reading through the icon many times anyway and one more time doesn't
seem like it will hurt (given that reading should be an extremely fast
operation; we're just iterating over an array at most a few hundred elements
long).

+}
+
 }  // namespace gfx