Use ScopedRTLFlipCanvas more pervasively for RTL flipping.

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/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "third_party/skia/include/core/SkXfermode.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"
 #include "ui/gfx/vector_icons.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) \
@@ skipping 45 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();
   bool flips_in_rtl = false;
 
   for (size_t i = 0; path_elements[i].type != END; i++) {
@@ skipping 190 matching lines @@
         flips_in_rtl = true;
         break;
       }
 
       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));
-  }
+  gfx::ScopedRTLFlipCanvas scoped_rtl_flip_canvas(
+      canvas, static_cast<int>(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(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,
                    VectorIconId badge_id)
       : CanvasImageSource(
             gfx::Size(static_cast<int>(dip_size), static_cast<int>(dip_size)),
@@ skipping 127 matching lines @@
 
 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