cocoa browser: fix meaning of "continuous pulsing"

chrome/browser/ui/cocoa/gradient_button_cell.mm

 // Copyright (c) 2012 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 "chrome/browser/ui/cocoa/gradient_button_cell.h"
 
 #include <cmath>
 
 #include "base/logging.h"
 #import "base/mac/scoped_nsobject.h"
@@ skipping 32 matching lines @@
 
 // Note: due to a bug (?), drawWithFrame:inView: does not call
 // drawBorderAndFillForTheme::::: unless the mouse is inside.  The net
 // effect is that our "fade out" when the mouse leaves becaumes
 // instantaneous.  When I "fixed" it things looked horrible; the
 // hover-overed bookmark button would stay highlit for 0.4 seconds
 // which felt like latency/lag.  I'm leaving the "bug" in place for
 // now so we don't suck.  -jrg
 static const NSTimeInterval kAnimationHideDuration = 0.4;
 
-static const NSTimeInterval kAnimationContinuousCycleDuration = 0.4;
-
 @implementation GradientButtonCell
 
 @synthesize hoverAlpha = hoverAlpha_;
 
 // For nib instantiations
 - (id)initWithCoder:(NSCoder*)decoder {
   if ((self = [super initWithCoder:decoder])) {
     [self sharedInit];
   }
   return self;
@@ skipping 11 matching lines @@
   if (trackingArea_) {
     [[self controlView] removeTrackingArea:trackingArea_];
     trackingArea_.reset();
   }
   [super dealloc];
 }
 
 // Return YES if we are pulsing (towards another state or continuously).
 - (BOOL)pulsing {
   if ((pulseState_ == gradient_button_cell::kPulsingOn) ||
-      (pulseState_ == gradient_button_cell::kPulsingOff) ||
-      (pulseState_ == gradient_button_cell::kPulsingContinuous))
+      (pulseState_ == gradient_button_cell::kPulsingOff))
     return YES;
   return NO;
 }
 
 // Perform one pulse step when animating a pulse.
 - (void)performOnePulseStep {
   NSTimeInterval thisUpdate = [NSDate timeIntervalSinceReferenceDate];
   NSTimeInterval elapsed = thisUpdate - lastHoverUpdate_;
   CGFloat opacity = [self hoverAlpha];
 
   // Update opacity based on state.
   // Adjust state if we have finished.
   switch (pulseState_) {
   case gradient_button_cell::kPulsingOn:
     opacity += elapsed / kAnimationShowDuration;
     if (opacity > 1.0) {
       [self setPulseState:gradient_button_cell::kPulsedOn];
       return;
     }
     break;
   case gradient_button_cell::kPulsingOff:
     opacity -= elapsed / kAnimationHideDuration;
     if (opacity < 0.0) {
       [self setPulseState:gradient_button_cell::kPulsedOff];
       return;
     }
     break;
-  case gradient_button_cell::kPulsingContinuous:
-    opacity += elapsed / kAnimationContinuousCycleDuration * pulseMultiplier_;
-    if (opacity > 1.0) {
-      opacity = 1.0;
-      pulseMultiplier_ *= -1.0;
-    } else if (opacity < 0.0) {
-      opacity = 0.0;
-      pulseMultiplier_ *= -1.0;
-    }
-    outerStrokeAlphaMult_ = opacity;
+  case gradient_button_cell::kPulsingStuckOn:
+    outerStrokeAlphaMult_ = 1.0;
     break;
   default:
     NOTREACHED() << "unknown pulse state";
   }
 
   // Update our control.
   lastHoverUpdate_ = thisUpdate;
   [self setHoverAlpha:opacity];
   [[self controlView] setNeedsDisplay:YES];
 
   // If our state needs it, keep going.
   if ([self pulsing]) {
     [self performSelector:_cmd withObject:nil afterDelay:0.02];
   }
 }
 
 - (gradient_button_cell::PulseState)pulseState {
   return pulseState_;
 }
 
 // Set the pulsing state.  This can either set the pulse to on or off
 // immediately (e.g. kPulsedOn, kPulsedOff) or initiate an animated
 // state change.
 - (void)setPulseState:(gradient_button_cell::PulseState)pstate {
   pulseState_ = pstate;
-  pulseMultiplier_ = 0.0;
   [NSObject cancelPreviousPerformRequestsWithTarget:self];
   lastHoverUpdate_ = [NSDate timeIntervalSinceReferenceDate];
 
   switch (pstate) {
   case gradient_button_cell::kPulsedOn:
   case gradient_button_cell::kPulsedOff:
     outerStrokeAlphaMult_ = 1.0;
     [self setHoverAlpha:((pulseState_ == gradient_button_cell::kPulsedOn) ?
                          1.0 : 0.0)];
     [[self controlView] setNeedsDisplay:YES];
     break;
   case gradient_button_cell::kPulsingOn:
   case gradient_button_cell::kPulsingOff:
     outerStrokeAlphaMult_ = 1.0;
     // Set initial value then engage timer.
     [self setHoverAlpha:((pulseState_ == gradient_button_cell::kPulsingOn) ?
                          0.0 : 1.0)];
     [self performOnePulseStep];
     break;
-  case gradient_button_cell::kPulsingContinuous:
+  case gradient_button_cell::kPulsingStuckOn:
     // Semantics of continuous pulsing are that we pulse independent
     // of mouse position.
-    pulseMultiplier_ = 1.0;
     [self performOnePulseStep];
     break;
   default:
     CHECK(0);
     break;
   }
 }
 
 - (void)safelyStopPulsing {
   [NSObject cancelPreviousPerformRequestsWithTarget:self];
 }
 
-- (void)setIsContinuousPulsing:(BOOL)continuous {
-  if (!continuous && pulseState_ != gradient_button_cell::kPulsingContinuous)
+- (void)setPulseIsStuckOn:(BOOL)on {
+  if (!on && pulseState_ != gradient_button_cell::kPulsingStuckOn)
     return;
-  if (continuous) {
-    [self setPulseState:gradient_button_cell::kPulsingContinuous];
+  if (on) {
+    [self setPulseState:gradient_button_cell::kPulsingStuckOn];
   } else {
     [self setPulseState:(isMouseInside_ ? gradient_button_cell::kPulsedOn :
                          gradient_button_cell::kPulsedOff)];
   }
 }
 
-- (BOOL)isContinuousPulsing {
-  return (pulseState_ == gradient_button_cell::kPulsingContinuous) ?
+- (BOOL)isPulseStuckOn {
+  return (pulseState_ == gradient_button_cell::kPulsingStuckOn) ?
       YES : NO;
 }
 
 #if 1
 // If we are not continuously pulsing, perform a pulse animation to
 // reflect our new state.
 - (void)setMouseInside:(BOOL)flag animate:(BOOL)animated {
   isMouseInside_ = flag;
-  if (pulseState_ != gradient_button_cell::kPulsingContinuous) {
+  if (pulseState_ != gradient_button_cell::kPulsingStuckOn) {
     if (animated) {
       // In Material Design, if the button is already fully on, don't pulse it
       // on again if the mouse is within its bounds.
       if ([self tag] == [self isMaterialDesignButtonType] &&
           isMouseInside_ && pulseState_ == gradient_button_cell::kPulsedOn) {
         return;
       }
 
       [self setPulseState:(isMouseInside_ ? gradient_button_cell::kPulsingOn :
                            gradient_button_cell::kPulsingOff)];
@@ skipping 65 matching lines @@
   NSGradient* gradient = [[NSGradient alloc] initWithColorsAndLocations:
                           startColor, hoverAlpha * 0.33,
                           endColor, 1.0, nil];
 
   return [gradient autorelease];
 }
 
 - (void)sharedInit {
   shouldTheme_ = YES;
   pulseState_ = gradient_button_cell::kPulsedOff;
-  pulseMultiplier_ = 1.0;
   outerStrokeAlphaMult_ = 1.0;
   gradient_.reset([[self gradientForHoverAlpha:0.0 isThemed:NO] retain]);
 }
 
 - (void)setShouldTheme:(BOOL)shouldTheme {
   shouldTheme_ = shouldTheme;
 }
 
 - (NSImage*)overlayImage {
   return overlayImage_.get();
@@ skipping 292 matching lines @@
   // Stroke the borders and appropriate fill gradient. If we're borderless, the
   // only time we want to draw the inner gradient is if we're highlighted or if
   // we're drawing the focus ring manually. In Material Design, the "border" is
   // actually a highlight, which should be drawn if
   // |showsBorderOnlyWhileMouseInside| is true.
   BOOL hasMaterialHighlight =
       [self isMaterialDesignButtonType] &&
       ![self showsBorderOnlyWhileMouseInside] &&
       enabled;
   if (([self isBordered] && ![self showsBorderOnlyWhileMouseInside]) ||
-      pressed || [self isMouseInside] || [self isContinuousPulsing] ||
+      pressed || [self isMouseInside] || [self isPulseStuckOn] ||
       hasMaterialHighlight) {
     // When pulsing we want the bookmark to stand out a little more.
     BOOL showClickedGradient = pressed ||
-        (pulseState_ == gradient_button_cell::kPulsingContinuous);
+        (pulseState_ == gradient_button_cell::kPulsingStuckOn);
     BOOL showHighlightGradient = [self isHighlighted] || hasMaterialHighlight;
 
     [self drawBorderAndFillForTheme:themeProvider
                         controlView:controlView
                           innerPath:innerPath
                 showClickedGradient:showClickedGradient
               showHighlightGradient:showHighlightGradient
                          hoverAlpha:[self hoverAlpha]
                              active:active
                           cellFrame:cellFrame
@@ skipping 238 matching lines @@
                              options:options
                                owner:self
                             userInfo:nil]);
   if (isMouseInside_ != mouseInView) {
     [self setMouseInside:mouseInView animate:NO];
     [controlView setNeedsDisplay:YES];
   }
 }
 
 @end