Cros system menu - Use WiFi strike-through image for "No networks" row

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 130 matching lines @@
 
       case MOVE_TO: {
         SkScalar x = path_elements[++i].arg;
         SkScalar y = path_elements[++i].arg;
         path.moveTo(x, y);
         break;
       }
 
       case R_MOVE_TO: {
         if (previous_command_type == CLOSE) {
-          // This triggers injectMoveToIfNeeded() so that the next subpath will
-          // start at the correct place. See
-          // [ https://www.w3.org/TR/SVG/paths.html#PathDataClosePathCommand ].
+          // This triggers injectMoveToIfNeeded() so that the next subpath
+          // will start at the correct place. See [
+          // https://www.w3.org/TR/SVG/paths.html#PathDataClosePathCommand ].
           path.rLineTo(0, 0);
         }
 
         SkScalar x = path_elements[++i].arg;
         SkScalar y = path_elements[++i].arg;
         path.rMoveTo(x, y);
         break;
       }
 
       case ARC_TO:
       case R_ARC_TO: {
         SkScalar rx = path_elements[++i].arg;
         SkScalar ry = path_elements[++i].arg;
         SkScalar angle = path_elements[++i].arg;
         SkScalar large_arc_flag = path_elements[++i].arg;
         SkScalar arc_sweep_flag = path_elements[++i].arg;
         SkScalar x = path_elements[++i].arg;
         SkScalar y = path_elements[++i].arg;
 
         auto path_fn =
             command_type == ARC_TO
                 ? static_cast<void (SkPath::*)(
                       SkScalar, SkScalar, SkScalar, SkPath::ArcSize,
                       SkPath::Direction, SkScalar, SkScalar)>(&SkPath::arcTo)
                 : &SkPath::rArcTo;
         (path.*path_fn)(
             rx, ry, angle,
             large_arc_flag ? SkPath::kLarge_ArcSize : SkPath::kSmall_ArcSize,
-            arc_sweep_flag ? SkPath::kCW_Direction : SkPath::kCCW_Direction,
-            x, y);
+            arc_sweep_flag ? SkPath::kCW_Direction : SkPath::kCCW_Direction, x,
+            y);
         break;
       }
 
       case LINE_TO: {
         SkScalar x = path_elements[++i].arg;
         SkScalar y = path_elements[++i].arg;
         path.lineTo(x, y);
         break;
       }
 
@@ skipping 251 matching lines @@
   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,
                      int dip_size,
                      SkColor color) {
   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);
 }
 
 ImageSkia CreateVectorIcon(const VectorIcon& icon, SkColor color) {
-  const PathElement* one_x_path = icon.path_1x_ ? icon.path_1x_ : icon.path_;
-  int size = one_x_path[0].type == CANVAS_DIMENSIONS ? one_x_path[1].arg
-                                                     : kReferenceSizeDip;
-  return CreateVectorIcon(icon, size, 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()
                          : 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) {
+  const PathElement* one_x_path = icon.path_1x_ ? icon.path_1x_ : icon.path_;
+  return one_x_path[0].type == CANVAS_DIMENSIONS ? one_x_path[1].arg
+                                                 : kReferenceSizeDip;
+}
+
 }  // namespace gfx