Revert 152221 - chromeos: Sync animation.

ash/launcher/launcher_button.cc

 // 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 "ash/launcher/launcher_button.h"
 
 #include <algorithm>
+#include <vector>
 
 #include "ash/launcher/launcher_button_host.h"
 #include "grit/ui_resources.h"
 #include "skia/ext/image_operations.h"
 #include "ui/base/accessibility/accessible_view_state.h"
 #include "ui/base/animation/animation_delegate.h"
 #include "ui/base/animation/throb_animation.h"
 #include "ui/base/events.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/layer.h"
+#include "ui/compositor/layer_animation_element.h"
+#include "ui/compositor/layer_animation_observer.h"
+#include "ui/compositor/layer_animation_sequence.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia_operations.h"
+#include "ui/gfx/transform_util.h"
 #include "ui/views/controls/image_view.h"
 
 namespace {
 
 // Size of the bar. This is along the opposite axis of the shelf. For example,
 // if the shelf is aligned horizontally then this is the height of the bar.
 const int kBarSize = 3;
 const int kBarSpacing = 5;
 const int kIconSize = 32;
 const int kHopSpacing = 2;
@@ skipping 56 matching lines @@
     }
   }
 
  private:
   ui::ThrobAnimation animation_;
 
   DISALLOW_COPY_AND_ASSIGN(BarView);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
+// LauncherButton::IconPulseAnimation
+
+// IconPulseAnimation plays a pulse animation in a loop for given |icon_view|.
+// It iterates through all animations, wait for one duration then starts again.
+class LauncherButton::IconPulseAnimation {
+ public:
+  explicit IconPulseAnimation(IconView* icon_view)
+      : icon_view_(icon_view) {
+    SchedulePulseAnimations();
+  }
+  virtual ~IconPulseAnimation() {
+    // Restore icon_view_ on destruction.
+    ScheduleRestoreAnimation();
+  }
+
+ private:
+  // Animation duration in millisecond.
+  static const int kAnimationDurationInMs;
+
+  // Number of animations to run and animation parameters.
+  static const float kAnimationOpacity[];
+  static const float kAnimationScale[];
+
+  // Schedules pulse animations.
+  void SchedulePulseAnimations();
+
+  // Schedule an animation to restore the view to normal state.
+  void ScheduleRestoreAnimation();
+
+  IconView* icon_view_;  // Owned by views hierarchy of LauncherButton.
+
+  DISALLOW_COPY_AND_ASSIGN(IconPulseAnimation);
+};
+
+// static
+const int LauncherButton::IconPulseAnimation::kAnimationDurationInMs = 600;
+const float LauncherButton::IconPulseAnimation::kAnimationOpacity[] =
+    { 0.4f, 0.8f };
+const float LauncherButton::IconPulseAnimation::kAnimationScale[] =
+    { 0.8f, 1.0f };
+
+void LauncherButton::IconPulseAnimation::SchedulePulseAnimations() {
+  // The two animation set should have the same size.
+  DCHECK(arraysize(kAnimationOpacity) == arraysize(kAnimationScale));
+
+  scoped_ptr<ui::LayerAnimationSequence> opacity_sequence(
+      new ui::LayerAnimationSequence());
+  scoped_ptr<ui::LayerAnimationSequence> transform_sequence(
+      new ui::LayerAnimationSequence());
+
+  // The animations loop infinitely.
+  opacity_sequence->set_is_cyclic(true);
+  transform_sequence->set_is_cyclic(true);
+
+  for (size_t i = 0; i < arraysize(kAnimationOpacity); ++i) {
+    opacity_sequence->AddElement(
+        ui::LayerAnimationElement::CreateOpacityElement(
+            kAnimationOpacity[i],
+            base::TimeDelta::FromMilliseconds(kAnimationDurationInMs)));
+    transform_sequence->AddElement(
+        ui::LayerAnimationElement::CreateTransformElement(
+            ui::GetScaleTransform(icon_view_->GetLocalBounds().CenterPoint(),
+                                  kAnimationScale[i]),
+            base::TimeDelta::FromMilliseconds(kAnimationDurationInMs)));
+  }
+
+  ui::LayerAnimationElement::AnimatableProperties opacity_properties;
+  opacity_properties.insert(ui::LayerAnimationElement::OPACITY);
+  opacity_sequence->AddElement(
+      ui::LayerAnimationElement::CreatePauseElement(
+          opacity_properties,
+          base::TimeDelta::FromMilliseconds(kAnimationDurationInMs)));
+
+  ui::LayerAnimationElement::AnimatableProperties transform_properties;
+  transform_properties.insert(ui::LayerAnimationElement::TRANSFORM);
+  transform_sequence->AddElement(
+      ui::LayerAnimationElement::CreatePauseElement(
+          transform_properties,
+          base::TimeDelta::FromMilliseconds(kAnimationDurationInMs)));
+
+  std::vector<ui::LayerAnimationSequence*> animations;
+  // LayerAnimator::ScheduleTogether takes ownership of the sequences.
+  animations.push_back(opacity_sequence.release());
+  animations.push_back(transform_sequence.release());
+  icon_view_->layer()->GetAnimator()->ScheduleTogether(animations);
+}
+
+// Schedule an animation to restore the view to normal state.
+void LauncherButton::IconPulseAnimation::ScheduleRestoreAnimation() {
+  ui::Layer* layer = icon_view_->layer();
+  ui::ScopedLayerAnimationSettings settings(layer->GetAnimator());
+  layer->SetOpacity(1.0f);
+  layer->SetTransform(ui::Transform());
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // LauncherButton::IconView
 
 LauncherButton::IconView::IconView() : icon_size_(kIconSize) {
 }
 
 LauncherButton::IconView::~IconView() {
 }
 
 bool LauncherButton::IconView::HitTestRect(const gfx::Rect& rect) const {
   // Return false so that LauncherButton gets all the mouse events.
@@ skipping 77 matching lines @@
       scoped_setter.SetTransitionDuration(
           base::TimeDelta::FromMilliseconds(kHopUpMS));
       state_ |= state;
       UpdateState();
     } else {
       state_ |= state;
       UpdateState();
     }
     if (state & STATE_ATTENTION)
       bar_->ShowAttention(true);
+    if (state & STATE_PENDING)
+      icon_pulse_animation_.reset(new IconPulseAnimation(icon_view_));
   }
 }
 
 void LauncherButton::ClearState(State state) {
   if (state_ & state) {
     if (!ShouldHop(state) || ShouldHop(state_)) {
       ui::ScopedLayerAnimationSettings scoped_setter(
           icon_view_->layer()->GetAnimator());
       scoped_setter.SetTweenType(ui::Tween::LINEAR);
       scoped_setter.SetTransitionDuration(
           base::TimeDelta::FromMilliseconds(kHopDownMS));
       state_ &= ~state;
       UpdateState();
     } else {
       state_ &= ~state;
       UpdateState();
     }
     if (state & STATE_ATTENTION)
       bar_->ShowAttention(false);
+    if (state & STATE_PENDING)
+      icon_pulse_animation_.reset();
   }
 }
 
 gfx::Rect LauncherButton::GetIconBounds() const {
   return icon_view_->bounds();
 }
 
 bool LauncherButton::OnMousePressed(const ui::MouseEvent& event) {
   CustomButton::OnMousePressed(event);
   host_->PointerPressedOnButton(this, LauncherButtonHost::MOUSE, event);
@@ skipping 125 matching lines @@
 
 LauncherButton::IconView* LauncherButton::CreateIconView() {
   return new IconView;
 }
 
 bool LauncherButton::IsShelfHorizontal() const {
   return host_->GetShelfAlignment() == SHELF_ALIGNMENT_BOTTOM;
 }
 
 void LauncherButton::UpdateState() {
-  if (state_ == STATE_NORMAL) {
+  if (state_ == STATE_NORMAL || state_ & STATE_PENDING) {
     bar_->SetVisible(false);
   } else {
     int bar_id;
     if (IsShelfHorizontal()) {
       if (state_ & (STATE_HOVERED | STATE_FOCUSED | STATE_ATTENTION))
         bar_id = IDR_AURA_LAUNCHER_UNDERLINE_HOVER;
       else if (state_ & STATE_ACTIVE)
         bar_id = IDR_AURA_LAUNCHER_UNDERLINE_ACTIVE;
       else
         bar_id = IDR_AURA_LAUNCHER_UNDERLINE_RUNNING;
@@ skipping 29 matching lines @@
       bar_->SetVerticalAlignment(views::ImageView::CENTER);
       break;
   }
 
   Layout();
   SchedulePaint();
 }
 
 }  // namespace internal
 }  // namespace ash