Retires scoped_ptr for BoundsAnimator of message_list_view.

ui/message_center/views/message_list_view.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 "base/command_line.h"
 #include "ui/gfx/animation/slide_animation.h"
 #include "ui/message_center/message_center_style.h"
 #include "ui/message_center/message_center_switches.h"
 #include "ui/message_center/views/message_center_view.h"
 #include "ui/message_center/views/message_list_view.h"
 #include "ui/message_center/views/message_view.h"
-#include "ui/views/animation/bounds_animator.h"
 #include "ui/views/background.h"
 #include "ui/views/border.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/views/widget/widget.h"
 
 namespace message_center {
 
 namespace {
 const int kAnimateClearingNextNotificationDelayMS = 40;
 }  // namespace
 
 MessageListView::MessageListView(MessageCenterView* message_center_view,
                                  bool top_down)
     : message_center_view_(message_center_view),
       reposition_top_(-1),
       fixed_height_(0),
       has_deferred_task_(false),
       clear_all_started_(false),
       top_down_(top_down),
+      animator_(this),
       weak_ptr_factory_(this) {
   views::BoxLayout* layout =
       new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 1);
   layout->SetDefaultFlex(1);
   SetLayoutManager(layout);
 
   // Set the margin to 0 for the layout. BoxLayout assumes the same margin
   // for top and bottom, but the bottom margin here should be smaller
   // because of the shadow of message view. Use an empty border instead
   // to provide this margin.
   gfx::Insets shadow_insets = MessageView::GetShadowInsets();
   set_background(
       views::Background::CreateSolidBackground(kMessageCenterBackgroundColor));
   SetBorder(views::Border::CreateEmptyBorder(
       top_down ? 0 : kMarginBetweenItems - shadow_insets.top(),    /* top */
       kMarginBetweenItems - shadow_insets.left(),                  /* left */
       top_down ? kMarginBetweenItems - shadow_insets.bottom() : 0, /* bottom */
       kMarginBetweenItems - shadow_insets.right() /* right */));
+  animator_.AddObserver(this);
 }
 
 MessageListView::~MessageListView() {
-  if (animator_.get())
-    animator_->RemoveObserver(this);
+  animator_.RemoveObserver(this);
 }
 
 void MessageListView::Layout() {
-  if (animator_.get() && animator_->IsAnimating())
+  if (animator_.IsAnimating())
     return;
 
   gfx::Rect child_area = GetContentsBounds();
   int top = child_area.y();
   int between_items =
       kMarginBetweenItems - MessageView::GetShadowInsets().bottom();
 
   for (int i = 0; i < child_count(); ++i) {
     views::View* child = child_at(i);
     if (!child->visible())
@@ skipping 28 matching lines @@
 }
 
 void MessageListView::RemoveNotification(MessageView* view) {
   DCHECK_EQ(view->parent(), this);
   if (GetContentsBounds().IsEmpty()) {
     delete view;
   } else {
     if (view->layer()) {
       deleting_views_.insert(view);
     } else {
-      if (animator_.get())
-        animator_->StopAnimatingView(view);
+      animator_.StopAnimatingView(view);
       delete view;
     }
     DoUpdateIfPossible();
   }
 }
 
 void MessageListView::UpdateNotification(MessageView* view,
                                          const Notification& notification) {
   int index = GetIndexOf(view);
   DCHECK_LE(0, index);  // GetIndexOf is negative if not a child.
 
-  if (animator_.get())
-    animator_->StopAnimatingView(view);
+  animator_.StopAnimatingView(view);
   if (deleting_views_.find(view) != deleting_views_.end())
     deleting_views_.erase(view);
   if (deleted_when_done_.find(view) != deleted_when_done_.end())
     deleted_when_done_.erase(view);
   view->UpdateWithNotification(notification);
   DoUpdateIfPossible();
 }
 
 gfx::Size MessageListView::GetPreferredSize() const {
   int width = 0;
@@ skipping 45 matching lines @@
 
 void MessageListView::SetRepositionTarget(const gfx::Rect& target) {
   reposition_top_ = target.y();
   fixed_height_ = GetHeightForWidth(width());
 }
 
 void MessageListView::ResetRepositionSession() {
   // Don't call DoUpdateIfPossible(), but let Layout() do the task without
   // animation. Reset will cause the change of the bubble size itself, and
   // animation from the old location will look weird.
-  if (reposition_top_ >= 0 && animator_.get()) {
+  if (reposition_top_ >= 0) {
     has_deferred_task_ = false;
     // cancel cause OnBoundsAnimatorDone which deletes |deleted_when_done_|.
-    animator_->Cancel();
+    animator_.Cancel();
     STLDeleteContainerPointers(deleting_views_.begin(), deleting_views_.end());
     deleting_views_.clear();
     adding_views_.clear();
-    animator_.reset();
   }
 
   reposition_top_ = -1;
   fixed_height_ = 0;
 }
 
 void MessageListView::ClearAllNotifications(
     const gfx::Rect& visible_scroll_rect) {
   for (int i = 0; i < child_count(); ++i) {
     views::View* child = child_at(i);
     if (!child->visible())
       continue;
     if (gfx::IntersectRects(child->bounds(), visible_scroll_rect).IsEmpty())
       continue;
     clearing_all_views_.push_back(child);
   }
   DoUpdateIfPossible();
 }
 
 void MessageListView::OnBoundsAnimatorProgressed(
     views::BoundsAnimator* animator) {
-  DCHECK_EQ(animator_.get(), animator);
+  DCHECK_EQ(&animator_, animator);
   for (std::set<views::View*>::iterator iter = deleted_when_done_.begin();
        iter != deleted_when_done_.end(); ++iter) {
     const gfx::SlideAnimation* animation = animator->GetAnimationForView(*iter);
     if (animation)
       (*iter)->layer()->SetOpacity(animation->CurrentValueBetween(1.0, 0.0));
   }
 }
 
 void MessageListView::OnBoundsAnimatorDone(views::BoundsAnimator* animator) {
   STLDeleteContainerPointers(deleted_when_done_.begin(),
@@ skipping 20 matching lines @@
              deleting_views_.end() &&
          deleted_when_done_.find(const_cast<views::View*>(child)) ==
              deleted_when_done_.end();
 }
 
 void MessageListView::DoUpdateIfPossible() {
   gfx::Rect child_area = GetContentsBounds();
   if (child_area.IsEmpty())
     return;
 
-  if (animator_.get() && animator_->IsAnimating()) {
+  if (animator_.IsAnimating()) {
     has_deferred_task_ = true;
     return;
   }
 
-  if (!animator_.get()) {
-    animator_.reset(new views::BoundsAnimator(this));
-    animator_->AddObserver(this);
-  }
-
   if (!clearing_all_views_.empty()) {
     AnimateClearingOneNotification();
     return;
   }
 
   if (top_down_ ||
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableMessageCenterAlwaysScrollUpUponNotificationRemoval))
     AnimateNotificationsBelowTarget();
   else
@@ skipping 55 matching lines @@
       if (AnimateChild(child, bottom - child->height(), child->height()))
         bottom -= child->height() + between_items;
     }
   }
 }
 
 bool MessageListView::AnimateChild(views::View* child, int top, int height) {
   gfx::Rect child_area = GetContentsBounds();
   if (adding_views_.find(child) != adding_views_.end()) {
     child->SetBounds(child_area.right(), top, child_area.width(), height);
-    animator_->AnimateViewTo(
+    animator_.AnimateViewTo(
         child, gfx::Rect(child_area.x(), top, child_area.width(), height));
   } else if (deleting_views_.find(child) != deleting_views_.end()) {
     DCHECK(child->layer());
     // No moves, but animate to fade-out.
-    animator_->AnimateViewTo(child, child->bounds());
+    animator_.AnimateViewTo(child, child->bounds());
     deleted_when_done_.insert(child);
     return false;
   } else {
     gfx::Rect target(child_area.x(), top, child_area.width(), height);
     if (child->bounds().origin() != target.origin())
-      animator_->AnimateViewTo(child, target);
+      animator_.AnimateViewTo(child, target);
     else
       child->SetBoundsRect(target);
   }
   return true;
 }
 
 void MessageListView::AnimateClearingOneNotification() {
   DCHECK(!clearing_all_views_.empty());
 
   clear_all_started_ = true;
 
   views::View* child = clearing_all_views_.front();
   clearing_all_views_.pop_front();
 
   // Slide from left to right.
   gfx::Rect new_bounds = child->bounds();
   new_bounds.set_x(new_bounds.right() + kMarginBetweenItems);
-  animator_->AnimateViewTo(child, new_bounds);
+  animator_.AnimateViewTo(child, new_bounds);
 
   // Schedule to start sliding out next notification after a short delay.
   if (!clearing_all_views_.empty()) {
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE, base::Bind(&MessageListView::AnimateClearingOneNotification,
                               weak_ptr_factory_.GetWeakPtr()),
         base::TimeDelta::FromMilliseconds(
             kAnimateClearingNextNotificationDelayMS));
   }
 }
 
 }  // namespace message_center