Use a layer transform for the waiting throbber

ui/gfx/paint_throbber.cc

 // Copyright (c) 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_throbber.h"
 
 #include "base/time/time.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "ui/gfx/animation/tween.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_utils.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/skia_util.h"
 
 namespace gfx {
 
 namespace {
 
 // The maximum size of the "spinning" state arc, in degrees.
 const int64_t kMaxArcSize = 270;
 
 // The amount of time it takes to grow the "spinning" arc from 0 to 270 degrees.
 const int64_t kArcTimeMs = 666;
 
 // The amount of time it takes for the "spinning" throbber to make a full
 // rotation.
 const int64_t kRotationTimeMs = 1568;
 
-void PaintArc(Canvas* canvas,
-              const Rect& bounds,
-              SkColor color,
-              SkScalar start_angle,
-              SkScalar sweep) {
-  // Stroke width depends on size.
-  // . For size < 28:          3 - (28 - size) / 16
-  // . For 28 <= size:         (8 + size) / 12
-  SkScalar stroke_width = bounds.width() < 28
-                              ? 3.0 - SkIntToScalar(28 - bounds.width()) / 16.0
-                              : SkIntToScalar(bounds.width() + 8) / 12.0;
-  Rect oval = bounds;
-  // Inset by half the stroke width to make sure the whole arc is inside
-  // the visible rect.
-  int inset = SkScalarCeilToInt(stroke_width / 2.0);
-  oval.Inset(inset, inset);
-
-  SkPath path;
-  path.arcTo(RectToSkRect(oval), start_angle, sweep, true);
-
-  SkPaint paint;
-  paint.setColor(color);
-  paint.setStrokeCap(SkPaint::kRound_Cap);
-  paint.setStrokeWidth(stroke_width);
-  paint.setStyle(SkPaint::kStroke_Style);
-  paint.setAntiAlias(true);
-  canvas->DrawPath(path, paint);
-}
-
 void CalculateWaitingAngles(const base::TimeDelta& elapsed_time,
                             int64_t* start_angle,
                             int64_t* sweep) {
   // Calculate start and end points. The angles are counter-clockwise because
   // the throbber spins counter-clockwise. The finish angle starts at 12 o'clock
   // (90 degrees) and rotates steadily. The start angle trails 180 degrees
   // behind, except for the first half revolution, when it stays at 12 o'clock.
   base::TimeDelta revolution_time = base::TimeDelta::FromMilliseconds(1320);
   int64_t twelve_oclock = 90;
   int64_t finish_angle_cc =
@@ skipping 35 matching lines @@
     start_angle -= (min_sweep_length - sweep);
     sweep = min_sweep_length;
   } else if (sweep <= 0.0 && sweep > -min_sweep_length) {
     start_angle += (-min_sweep_length - sweep);
     sweep = -min_sweep_length;
   }
 
   // To keep the sweep smooth, we have an additional rotation after each
   // |arc_time| period has elapsed. See SVG's 'rot' animation.
   int64_t rot_keyframe = (elapsed_time / (arc_time * 2)) % 4;
-  PaintArc(canvas, bounds, color, start_angle + rot_keyframe * kMaxArcSize,
-           sweep);
+  PaintThrobberArc(canvas, bounds, color,
+                   start_angle + rot_keyframe * kMaxArcSize, sweep);
 }
 
 }  // namespace
 
+void PaintThrobberArc(Canvas* canvas,
+                      const Rect& bounds,
+                      SkColor color,
+                      SkScalar start_angle,
+                      SkScalar sweep) {
+  // Stroke width depends on size.
+  // . For size < 28:          3 - (28 - size) / 16
+  // . For 28 <= size:         (8 + size) / 12
+  SkScalar stroke_width = bounds.width() < 28
+                              ? 3.0 - SkIntToScalar(28 - bounds.width()) / 16.0
+                              : SkIntToScalar(bounds.width() + 8) / 12.0;
+  Rect oval = bounds;
+  // Inset by half the stroke width to make sure the whole arc is inside
+  // the visible rect.
+  int inset = SkScalarCeilToInt(stroke_width / 2.0);
+  oval.Inset(inset, inset);
+
+  SkPath path;
+  path.arcTo(RectToSkRect(oval), start_angle, sweep, true);
+
+  SkPaint paint;
+  paint.setColor(color);
+  paint.setStrokeCap(SkPaint::kRound_Cap);
+  paint.setStrokeWidth(stroke_width);
+  paint.setStyle(SkPaint::kStroke_Style);
+  paint.setAntiAlias(true);
+  canvas->DrawPath(path, paint);
+}
+
 void PaintThrobberSpinning(Canvas* canvas,
                            const Rect& bounds,
                            SkColor color,
                            const base::TimeDelta& elapsed_time) {
   base::TimeDelta rotation_time =
       base::TimeDelta::FromMilliseconds(kRotationTimeMs);
   int64_t start_angle = 270 + 360 * elapsed_time / rotation_time;
   PaintThrobberSpinningWithStartAngle(canvas, bounds, color, elapsed_time,
                                       start_angle);
 }
 
 void PaintThrobberWaiting(Canvas* canvas,
     const Rect& bounds, SkColor color, const base::TimeDelta& elapsed_time) {
   int64_t start_angle = 0, sweep = 0;
   CalculateWaitingAngles(elapsed_time, &start_angle, &sweep);
-  PaintArc(canvas, bounds, color, start_angle, sweep);
+  PaintThrobberArc(canvas, bounds, color, start_angle, sweep);
 }
 
 void PaintThrobberSpinningAfterWaiting(Canvas* canvas,
                                        const Rect& bounds,
                                        SkColor color,
                                        const base::TimeDelta& elapsed_time,
                                        ThrobberWaitingState* waiting_state) {
   int64_t waiting_start_angle = 0, waiting_sweep = 0;
   CalculateWaitingAngles(waiting_state->elapsed_time, &waiting_start_angle,
                          &waiting_sweep);
@@ skipping 30 matching lines @@
       waiting_start_angle +
       360 * elapsed_time / base::TimeDelta::FromMilliseconds(kRotationTimeMs);
   base::TimeDelta effective_elapsed_time =
       elapsed_time + waiting_state->arc_time_offset;
 
   PaintThrobberSpinningWithStartAngle(canvas, bounds, blend_color,
                                       effective_elapsed_time, start_angle);
 }
 
 }  // namespace gfx