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 || state_ & STATE_PENDING) {
+  if (state_ == STATE_NORMAL) {
     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