Adds functionality to anchor widgets to the top-of-window views in immersive mode

chrome/browser/ui/views/frame/immersive_mode_controller_ash.cc

 // Copyright 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/views/frame/immersive_mode_controller_ash.h"
 
 #include "ash/ash_switches.h"
 #include "ash/shell.h"
 #include "ash/wm/window_properties.h"
 #include "base/command_line.h"
+#include "chrome/browser/ui/browser_commands.h"

[James Cook, 2013/04/11 23:35:58]

nit: Do you need this?

 #include "chrome/browser/ui/views/bookmarks/bookmark_bar_view.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #include "chrome/browser/ui/views/frame/top_container_view.h"
 #include "chrome/browser/ui/views/tabs/tab_strip.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
@@ skipping 17 matching lines @@
 // few pixels before the view goes completely off the screen, which reduces
 // the visual "pop" as the 2-pixel tall immersive-style tabs become visible.
 const int kAnimationOffsetY = 3;
 
 // Duration for the reveal show/hide slide animation. The slower duration is
 // used for the initial slide out to give the user more change to see what
 // happened.
 const int kRevealSlowAnimationDurationMs = 400;
 const int kRevealFastAnimationDurationMs = 200;
 
+// If |hovered| is true, moves the mouse above |view|. Moves it outside of
+// |view| otherwise.
+// Should not be called outside of tests.
+void MoveMouse(views::View* view, bool hovered) {
+  gfx::Point cursor_pos;
+  if (!hovered) {
+    int bottom_edge = view->bounds().bottom();
+    cursor_pos = gfx::Point(0, bottom_edge + 100);
+  }
+  views::View::ConvertPointToScreen(view, &cursor_pos);
+  aura::Env::GetInstance()->set_last_mouse_location(cursor_pos);
+}
+
 // Returns true if the currently active window is a transient child of
 // |toplevel|.
-bool IsActiveWindowTransientChildOf(gfx::NativeWindow toplevel) {
+bool IsActiveWindowTransientChildOf(aura::Window* toplevel) {
   aura::Window* active_window = aura::client::GetActivationClient(
       toplevel->GetRootWindow())->GetActiveWindow();
 
   if (!toplevel || !active_window)
     return false;
 
   for (aura::Window* window = active_window; window;
        window = window->transient_parent()) {
     if (window == toplevel)
       return true;
@@ skipping 16 matching lines @@
     if (controller_)
       controller_->UnlockRevealedState();
   }
 
  private:
   base::WeakPtr<ImmersiveModeControllerAsh> controller_;
 
   DISALLOW_COPY_AND_ASSIGN(RevealedLockAsh);
 };
 
+////////////////////////////////////////////////////////////////////////////////
+
+// Manages widgets which should move in sync with the top-of-window views.
+class AnchoredWidgetManager : public views::WidgetObserver {
+ public:
+  AnchoredWidgetManager(ImmersiveModeControllerAsh* controller,
+                        BrowserView* browser_view);
+  virtual ~AnchoredWidgetManager();
+
+  // Anchors |widget| such that it stays |y_offset| below the top-of-window
+  // views. |widget| will be repositioned whenever the top-of-window views are
+  // animated (top-of-window views revealing / unrevealing) or the top-of-window
+  // bounds change (eg the bookmark bar is shown).
+  // If the top-of-window views are revealed (or become revealed), |widget| will
+  // keep the top-of-window views revealed till |widget| is hidden or
+  // RemoveAnchoredWidget() is called.
+  void AddAnchoredWidget(views::Widget* widget, int y_offset);
+
+  // Stops managing |widget|'s y position.
+  // Closes the top-of-window views if no locks or other anchored widgets are
+  // keeping the top-of-window views revealed.
+  void RemoveAnchoredWidget(views::Widget* widget);
+
+  // Adjusts the y positions of the anchored widgets for the new top container
+  // bounds.
+  void OnTopContainerBoundsChanged();
+
+  const std::set<views::Widget*>& visible_anchored_widgets() const {
+    return visible_;
+  }
+
+ private:
+  // Updates |revealed_lock_| based on the visible anchored widgets.
+  void UpdateRevealedLock();
+
+  // Updates the y position of |widget| given |y_offset| and the top
+  // container's target bounds.
+  void UpdateWidgetBounds(views::Widget* widget, int y_offset);
+
+  // views::WidgetObserver overrides:
+  virtual void OnWidgetDestroying(views::Widget* widget) OVERRIDE;
+  virtual void OnWidgetVisibilityChanged(views::Widget* widget,
+                                         bool visible) OVERRIDE;
+
+  ImmersiveModeControllerAsh* controller_;
+
+  BrowserView* browser_view_;
+
+  // Mapping of anchored widgets to the y offset below the top-of-window views
+  // that they should be positioned at.
+  std::map<views::Widget*, int> widgets_;
+
+  // The subset of |widgets_| which are visible.
+  std::set<views::Widget*> visible_;
+
+  // Lock which keeps the top-of-window views revealed based on the visible
+  // anchored widgets.
+  scoped_ptr<ImmersiveModeController::RevealedLock> revealed_lock_;
+
+  DISALLOW_COPY_AND_ASSIGN(AnchoredWidgetManager);
+};
+
+AnchoredWidgetManager::AnchoredWidgetManager(
+    ImmersiveModeControllerAsh* controller,
+    BrowserView* browser_view)
+    : controller_(controller),
+      browser_view_(browser_view) {
+}
+
+AnchoredWidgetManager::~AnchoredWidgetManager() {
+  for (std::map<views::Widget*, int>::iterator it = widgets_.begin();
+       it != widgets_.end(); ++it) {
+    RemoveAnchoredWidget(it->first);
+  }
+}
+
+void AnchoredWidgetManager::AddAnchoredWidget(views::Widget* widget,
+                                              int y_offset) {
+  DCHECK(widget);
+  bool already_added = widgets_.count(widget);
+  widgets_[widget] = y_offset;
+
+  if (already_added)
+    return;
+
+  widget->AddObserver(this);
+
+  if (widget->IsVisible())
+    visible_.insert(widget);
+
+  UpdateRevealedLock();
+  UpdateWidgetBounds(widget, y_offset);
+}
+
+void AnchoredWidgetManager::RemoveAnchoredWidget(views::Widget* widget) {
+  if (!widgets_.count(widget))
+    return;
+
+  widget->RemoveObserver(this);
+  widgets_.erase(widget);
+  visible_.erase(widget);
+
+  UpdateRevealedLock();
+}
+
+void AnchoredWidgetManager::OnTopContainerBoundsChanged() {
+  for (std::map<views::Widget*, int>::iterator it = widgets_.begin();
+       it != widgets_.end(); ++it) {
+    UpdateWidgetBounds(it->first, it->second);
+  }
+
+  UpdateRevealedLock();
+}
+
+void AnchoredWidgetManager::UpdateRevealedLock() {
+  if (visible_.empty()) {
+    revealed_lock_.reset();
+  } else if (controller_->IsRevealed()) {
+    // It is hard to determine the required initial transforms and the required
+    // durations of the animations of |visible_| such that they appear to be
+    // anchored to the top-of-window views while the top-of-window views are
+    // animating. Skip to the end of the reveal animation instead.
+    // We do not query the controller's reveal state because we may be called
+    // as a result of LayoutBrowserView() in MaybeStartReveal() when
+    // |reveal_state_| is SLIDING_OPEN but no animation is running yet.
+    ui::Layer* top_container_layer = browser_view_->top_container()->layer();
+    if (top_container_layer &&
+        top_container_layer->GetAnimator()->is_animating()) {
+      controller_->MaybeRevealWithoutAnimation();
+    }
+
+    if (!revealed_lock_.get())
+      revealed_lock_.reset(controller_->GetRevealedLock());
+  }
+}
+
+void AnchoredWidgetManager::UpdateWidgetBounds(views::Widget* widget,
+                                               int y_offset) {
+  if (!widget->IsVisible())
+    return;
+
+  gfx::Rect top_container_target_bounds =
+      browser_view_->top_container()->GetTargetBoundsInScreen();
+  gfx::Rect bounds(widget->GetWindowBoundsInScreen());
+  bounds.set_y(
+      top_container_target_bounds.bottom() + y_offset);
+   widget->SetBounds(bounds);
+}
+
+void AnchoredWidgetManager::OnWidgetDestroying(views::Widget* widget) {
+  RemoveAnchoredWidget(widget);
+}
+
+void AnchoredWidgetManager::OnWidgetVisibilityChanged(views::Widget* widget,
+                                                      bool visible) {
+  if (visible)
+    visible_.insert(widget);
+  else
+    visible_.erase(widget);
+
+  UpdateRevealedLock();
+
+  std::map<views::Widget*, int>::iterator it = widgets_.find(widget);
+  DCHECK(it != widgets_.end());
+  UpdateWidgetBounds(it->first, it->second);
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // Observer to watch for window restore. views::Widget does not provide a hook
 // to observe for window restore, so do this at the Aura level.
 class ImmersiveModeControllerAsh::WindowObserver : public aura::WindowObserver {
  public:
   explicit WindowObserver(ImmersiveModeControllerAsh* controller)
       : controller_(controller) {
@@ skipping 29 matching lines @@
   }
 
  private:
   ImmersiveModeControllerAsh* controller_;  // Not owned.
 
   DISALLOW_COPY_AND_ASSIGN(WindowObserver);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
-class ImmersiveModeControllerAsh::AnimationObserver
-    : public ui::ImplicitAnimationObserver {
- public:
-  enum AnimationType {
-    SLIDE_OPEN,
-    SLIDE_CLOSED,
-  };
-
-  AnimationObserver(ImmersiveModeControllerAsh* controller, AnimationType type)
-      : controller_(controller), animation_type_(type) {}
-  virtual ~AnimationObserver() {}
-
-  // ui::ImplicitAnimationObserver overrides:
-  virtual void OnImplicitAnimationsCompleted() OVERRIDE {
-    if (animation_type_ == SLIDE_OPEN)
-      controller_->OnSlideOpenAnimationCompleted();
-    else if (animation_type_ == SLIDE_CLOSED)
-      controller_->OnSlideClosedAnimationCompleted();
-    else
-      NOTREACHED();
-  }
-
- private:
-  ImmersiveModeControllerAsh* controller_;
-  AnimationType animation_type_;
-
-  DISALLOW_COPY_AND_ASSIGN(AnimationObserver);
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
 ImmersiveModeControllerAsh::ImmersiveModeControllerAsh()
     : browser_view_(NULL),
       enabled_(false),
       reveal_state_(CLOSED),
       revealed_lock_count_(0),
       hide_tab_indicators_(false),
       native_window_(NULL),
       weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
 ImmersiveModeControllerAsh::~ImmersiveModeControllerAsh() {
   // The browser view is being destroyed so there's no need to update its
   // layout or layers, even if the top views are revealed. But the window
   // observers still need to be removed.
   EnableWindowObservers(false);
 }
 
 void ImmersiveModeControllerAsh::LockRevealedState() {
   ++revealed_lock_count_;
   if (revealed_lock_count_ == 1)
-    MaybeStartReveal();
+    MaybeStartReveal(ANIMATE_FAST);
 }
 
 void ImmersiveModeControllerAsh::UnlockRevealedState() {
   --revealed_lock_count_;
   DCHECK_GE(revealed_lock_count_, 0);
   if (revealed_lock_count_ == 0)
     MaybeEndReveal(ANIMATE_FAST);
 }
 
+void ImmersiveModeControllerAsh::MaybeRevealWithoutAnimation() {
+  MaybeStartReveal(ANIMATE_NO);
+}
+
 void ImmersiveModeControllerAsh::Init(BrowserView* browser_view) {
   browser_view_ = browser_view;
   // Browser view is detached from its widget during destruction. Cache the
   // window pointer so |this| can stop observing during destruction.
   native_window_ = browser_view_->GetNativeWindow();
   DCHECK(native_window_);
   EnableWindowObservers(true);
 
-  slide_open_observer_.reset(
-      new AnimationObserver(this, AnimationObserver::SLIDE_OPEN));
-  slide_closed_observer_.reset(
-      new AnimationObserver(this, AnimationObserver::SLIDE_CLOSED));
-
   // Optionally allow the tab indicators to be hidden.
   hide_tab_indicators_ = CommandLine::ForCurrentProcess()->
       HasSwitch(ash::switches::kAshImmersiveHideTabIndicators);
+
+  anchored_widget_manager_.reset(
+      new AnchoredWidgetManager(this, browser_view_));
 }
 
 void ImmersiveModeControllerAsh::SetEnabled(bool enabled) {
   DCHECK(browser_view_) << "Must initialize before enabling";
   if (enabled_ == enabled)
     return;
   enabled_ = enabled;
 
   if (enabled_) {
     // Animate enabling immersive mode by sliding out the top-of-window views.
     // No animation occurs if a lock is holding the top-of-window views open.
 
     // Do a reveal to set the initial state for the animation. (And any
     // required state in case the animation cannot run because of a lock holding
     // the top-of-window views open.)
-    StartReveal(ANIMATE_NO);
+    MaybeStartReveal(ANIMATE_NO);
 
     // Reset the mouse and the focus revealed locks so that they do not affect
     // whether the top-of-window views are hidden. Reacquire the locks if ending
     // the reveal is unsuccessful.
     bool had_mouse_revealed_lock = (mouse_revealed_lock_.get() != NULL);
     bool had_focus_revealed_lock = (focus_revealed_lock_.get() != NULL);
     mouse_revealed_lock_.reset();
     focus_revealed_lock_.reset();
 
     // Try doing the animation.
@@ skipping 49 matching lines @@
     if (reveal_layer)
       reveal_layer->parent()->StackAtTop(reveal_layer);
   }
 }
 
 ImmersiveModeControllerAsh::RevealedLock*
     ImmersiveModeControllerAsh::GetRevealedLock() {
   return new RevealedLockAsh(weak_ptr_factory_.GetWeakPtr());
 }
 
+void ImmersiveModeControllerAsh::AnchorWidgetToTopContainer(
+    views::Widget* widget,
+    int y_offset) {
+  anchored_widget_manager_->AddAnchoredWidget(widget, y_offset);
+}
+
+void ImmersiveModeControllerAsh::UnanchorWidgetFromTopContainer(
+    views::Widget* widget) {
+  anchored_widget_manager_->RemoveAnchoredWidget(widget);
+}
+
+void ImmersiveModeControllerAsh::OnTopContainerBoundsChanged() {
+  anchored_widget_manager_->OnTopContainerBoundsChanged();
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // Observers:
 
 void ImmersiveModeControllerAsh::OnMouseEvent(ui::MouseEvent* event) {
   if (!enabled_)
     return;
 
   if (event->flags() & ui::EF_IS_SYNTHESIZED)
     return;
 
@@ skipping 53 matching lines @@
     bool active) {
   // Mouse hover should not initiate revealing the top-of-window views while
   // |native_window_| is inactive.
   top_timer_.Stop();
 
   UpdateMouseRevealedLock(true);
   UpdateFocusRevealedLock();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// Animation observer:
+
+void ImmersiveModeControllerAsh::OnImplicitAnimationsCompleted() {
+  if (reveal_state_ == SLIDING_OPEN)
+    OnSlideOpenAnimationCompleted();
+  else if (reveal_state_ == SLIDING_CLOSED)
+    OnSlideClosedAnimationCompleted();
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // Testing interface:
 
 void ImmersiveModeControllerAsh::SetHideTabIndicatorsForTest(bool hide) {
   hide_tab_indicators_ = hide;
 }
 
 void ImmersiveModeControllerAsh::StartRevealForTest(bool hovered) {
-  StartReveal(ANIMATE_NO);
-  SetMouseHoveredForTest(hovered);
+  MaybeStartReveal(ANIMATE_NO);
+  MoveMouse(browser_view_->top_container(), hovered);
+  UpdateMouseRevealedLock(false);
 }
 
 void ImmersiveModeControllerAsh::SetMouseHoveredForTest(bool hovered) {
-  views::View* top_container = browser_view_->top_container();
-  gfx::Point cursor_pos;
-  if (!hovered) {
-    int bottom_edge = top_container->bounds().bottom();
-    cursor_pos = gfx::Point(0, bottom_edge + 100);
-  }
-  views::View::ConvertPointToScreen(top_container, &cursor_pos);
-  aura::Env::GetInstance()->set_last_mouse_location(cursor_pos);
-
+  MoveMouse(browser_view_->top_container(), hovered);
   UpdateMouseRevealedLock(false);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // private:
 
 void ImmersiveModeControllerAsh::EnableWindowObservers(bool enable) {
   if (!native_window_) {
     DCHECK(!enable) << "ImmersiveModeControllerAsh not initialized";
     return;
@@ skipping 10 matching lines @@
     focus_manager->RemoveFocusChangeListener(this);
   }
 
   if (enable)
     native_window_->AddPreTargetHandler(this);
   else
     native_window_->RemovePreTargetHandler(this);
 
   // The window observer adds and removes itself from the native window.
   window_observer_.reset(enable ? new WindowObserver(this) : NULL);
+
+  if (!enable)
+    StopObservingImplicitAnimations();
 }
 
 void ImmersiveModeControllerAsh::UpdateMouseRevealedLock(bool maybe_drag) {
   if (!enabled_)
     return;
 
   // Hover cannot initiate a reveal when the top-of-window views are sliding
   // closed or are closed. (With the exception of hovering at y = 0 which is
   // handled in OnMouseEvent() ).
   if (reveal_state_ == SLIDING_CLOSED || reveal_state_ == CLOSED)
@@ skipping 67 matching lines @@
       return 0;
     case ANIMATE_SLOW:
       return kRevealSlowAnimationDurationMs;
     case ANIMATE_FAST:
       return kRevealFastAnimationDurationMs;
   }
   NOTREACHED();
   return 0;
 }
 
-void ImmersiveModeControllerAsh::MaybeStartReveal() {
-  if (enabled_ && reveal_state_ != REVEALED)
-    StartReveal(ANIMATE_FAST);
-}
+void ImmersiveModeControllerAsh::MaybeStartReveal(Animate animate) {
+  if (!enabled_)
+    return;
 
-void ImmersiveModeControllerAsh::StartReveal(Animate animate) {
-  if (reveal_state_ == CLOSED) {
-    reveal_state_ = SLIDING_OPEN;
+  // Callers with ANIMATE_NO expect this function to synchronously reveal the
+  // top-of-window views. In particular, this property is used to terminate the
+  // reveal animation if an equivalent animation for the anchored widgets
+  // cannot be created.
+  if (reveal_state_ == REVEALED ||
+      (reveal_state_ == SLIDING_OPEN && animate != ANIMATE_NO)) {
+    return;
+  }
+
+  RevealState previous_reveal_state = reveal_state_;
+  reveal_state_ = SLIDING_OPEN;
+  if (previous_reveal_state == CLOSED) {
     // Turn on layer painting so we can smoothly animate.
     EnablePaintToLayer(true);
 
     // Ensure window caption buttons are updated and the view bounds are
     // computed at normal (non-immersive-style) size.
     LayoutBrowserView(false);
 
+    // Do not do any more processing if LayoutBrowserView() changed
+    // |reveal_state_|.
+    if (reveal_state_ != SLIDING_OPEN)
+      return;
+
     if (animate != ANIMATE_NO) {
       // Now that we have a layer, move it to the initial offscreen position.
       ui::Layer* layer = browser_view_->top_container()->layer();
       gfx::Transform transform;
       transform.Translate(0, -layer->bounds().height() + kAnimationOffsetY);
       layer->SetTransform(transform);
+
+      typedef std::set<views::Widget*> WidgetSet;
+      const WidgetSet& visible_widgets =
+          anchored_widget_manager_->visible_anchored_widgets();
+      for (WidgetSet::const_iterator it = visible_widgets.begin();
+           it != visible_widgets.end(); ++it) {
+        (*it)->GetNativeWindow()->SetTransform(transform);
+      }
     }
-    // Slide in the reveal view.
-    AnimateSlideOpen(GetAnimationDuration(animate));
-  } else if (reveal_state_ == SLIDING_CLOSED) {
-    reveal_state_ = SLIDING_OPEN;
-    // Reverse the animation.
-    AnimateSlideOpen(GetAnimationDuration(animate));
   }
+  // Slide in the reveal view.
+  DoAnimation(gfx::Transform(), GetAnimationDuration(animate));
 }
 
 void ImmersiveModeControllerAsh::EnablePaintToLayer(bool enable) {
   browser_view_->top_container()->SetPaintToLayer(enable);
 
   // Views software compositing is not fully layer aware. If the bookmark bar
   // is detached while the top container layer slides on or off the screen,
   // the pixels that become exposed are the remnants of the last software
   // composite of the BrowserView, not the freshly-exposed bookmark bar.
   // Force the bookmark bar to paint to a layer so the views composite
   // properly. The infobar container does not need this treatment because
   // BrowserView::PaintChildren() always draws it last when it is visible.
   BookmarkBarView* bookmark_bar = browser_view_->bookmark_bar();
   if (!bookmark_bar)
     return;
   if (enable && bookmark_bar->IsDetached())
     bookmark_bar->SetPaintToLayer(true);
   else
     bookmark_bar->SetPaintToLayer(false);
 }
 
 void ImmersiveModeControllerAsh::LayoutBrowserView(bool immersive_style) {
   // Update the window caption buttons.
   browser_view_->GetWidget()->non_client_view()->frame_view()->
       ResetWindowControls();
   browser_view_->tabstrip()->SetImmersiveStyle(immersive_style);
   browser_view_->frame()->GetRootView()->Layout();
 }
 
-void ImmersiveModeControllerAsh::AnimateSlideOpen(int duration_ms) {
-  ui::Layer* layer = browser_view_->top_container()->layer();
-  // Stop any slide closed animation in progress.
-  layer->GetAnimator()->AbortAllAnimations();
+void ImmersiveModeControllerAsh::OnSlideOpenAnimationCompleted() {
+  DCHECK_EQ(SLIDING_OPEN, reveal_state_);
+  reveal_state_ = REVEALED;
 
-  ui::ScopedLayerAnimationSettings settings(layer->GetAnimator());
-  settings.AddObserver(slide_open_observer_.get());
-  settings.SetTweenType(ui::Tween::EASE_OUT);
-  settings.SetTransitionDuration(
-      base::TimeDelta::FromMilliseconds(duration_ms));
-  layer->SetTransform(gfx::Transform());
+  // The user may not have moved the mouse since the reveal was initiated.
+  // Update the revealed lock to reflect the mouse's current state.
+  UpdateMouseRevealedLock(true);
 }
 
-void ImmersiveModeControllerAsh::OnSlideOpenAnimationCompleted() {
-  if (reveal_state_ == SLIDING_OPEN) {
-    reveal_state_ = REVEALED;
+void ImmersiveModeControllerAsh::MaybeEndReveal(Animate animate) {
+  if (!enabled_ || revealed_lock_count_ != 0)
+    return;
 
-    // The user may not have moved the mouse since the reveal was initiated.
-    // Update the revealed lock to reflect the mouse's current state.
-    UpdateMouseRevealedLock(true);
+  // Callers with ANIMATE_NO expect this function to synchronously close the
+  // top-of-window views.
+  if (reveal_state_ == CLOSED ||
+      (reveal_state_ == SLIDING_CLOSED && animate != ANIMATE_NO)) {
+    return;
+  }
+
+  // Visible anchored widgets keep the top-of-window views revealed.
+  DCHECK(anchored_widget_manager_->visible_anchored_widgets().empty());
+
+  reveal_state_ = SLIDING_CLOSED;
+  int duration_ms = GetAnimationDuration(animate);
+  if (duration_ms > 0) {
+    // The bookmark bar may have become detached during the reveal so ensure
+    // layers are available. This is a no-op for the top container.
+    EnablePaintToLayer(true);
+
+    ui::Layer* top_container_layer = browser_view_->top_container()->layer();
+    gfx::Transform target_transform;
+    target_transform.Translate(0,
+        -top_container_layer->bounds().height() + kAnimationOffsetY);
+
+    DoAnimation(target_transform, duration_ms);
+  } else {
+    OnSlideClosedAnimationCompleted();
   }
 }
 
-void ImmersiveModeControllerAsh::MaybeEndReveal(Animate animate) {
-  if (enabled_ && reveal_state_ != CLOSED && revealed_lock_count_ == 0)
-    EndReveal(animate);
+void ImmersiveModeControllerAsh::OnSlideClosedAnimationCompleted() {
+  DCHECK_EQ(SLIDING_CLOSED, reveal_state_);
+  reveal_state_ = CLOSED;
+  // Layers aren't needed after animation completes.
+  EnablePaintToLayer(false);
+  // Update tabstrip for closed state.
+  LayoutBrowserView(true);
 }
 
-void ImmersiveModeControllerAsh::EndReveal(Animate animate) {
-  if (reveal_state_ == SLIDING_OPEN || reveal_state_ == REVEALED) {
-    reveal_state_ = SLIDING_CLOSED;
-    int duration_ms = GetAnimationDuration(animate);
-    if (duration_ms > 0) {
-      // Bookmark bar have become detached during the reveal so ensure
-      // layers are available. This is a no-op for top container.
-      EnablePaintToLayer(true);
-      AnimateSlideClosed(duration_ms);
-    } else {
-      OnSlideClosedAnimationCompleted();
-    }
+void ImmersiveModeControllerAsh::DoAnimation(
+    const gfx::Transform& target_transform,
+    int duration_ms) {
+  StopObservingImplicitAnimations();
+  DoLayerAnimation(browser_view_->top_container()->layer(), target_transform,
+      duration_ms, this);
+
+  typedef std::set<views::Widget*> WidgetSet;
+  const WidgetSet& visible_widgets =
+      anchored_widget_manager_->visible_anchored_widgets();
+  for (WidgetSet::const_iterator it = visible_widgets.begin();
+       it != visible_widgets.end(); ++it) {
+    // The anchored widget's bounds are set to the target bounds right when the
+    // animation starts. The transform is used to animate the widget's position.
+    // Using the target bounds allows us to "stay anchored" if other code
+    // changes the widget bounds in the middle of the animation. (This is the
+    // case if the fullscreen exit bubble type is changed during the immersive
+    // reveal animation).
+    DoLayerAnimation((*it)->GetNativeWindow()->layer(), gfx::Transform(),
+        duration_ms, NULL);
   }
 }
 
-void ImmersiveModeControllerAsh::AnimateSlideClosed(int duration_ms) {
-  // Stop any slide open animation in progress, but don't skip to the end. This
-  // avoids a visual "pop" when starting a hide in the middle of a show.
-  ui::Layer* layer = browser_view_->top_container()->layer();
-  layer->GetAnimator()->AbortAllAnimations();
-
+void ImmersiveModeControllerAsh::DoLayerAnimation(
+    ui::Layer* layer,
+    const gfx::Transform& target_transform,
+    int duration_ms,
+    ui::ImplicitAnimationObserver* observer) {
   ui::ScopedLayerAnimationSettings settings(layer->GetAnimator());
   settings.SetTweenType(ui::Tween::EASE_OUT);
   settings.SetTransitionDuration(
       base::TimeDelta::FromMilliseconds(duration_ms));
-  settings.AddObserver(slide_closed_observer_.get());
-  gfx::Transform transform;
-  transform.Translate(0, -layer->bounds().height() + kAnimationOffsetY);
-  layer->SetTransform(transform);
+  settings.SetPreemptionStrategy(
+      ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+  if (observer)
+    settings.AddObserver(observer);
+  layer->SetTransform(target_transform);
 }
-
-void ImmersiveModeControllerAsh::OnSlideClosedAnimationCompleted() {
-  if (reveal_state_ == SLIDING_CLOSED) {
-    reveal_state_ = CLOSED;
-    // Layers aren't needed after animation completes.
-    EnablePaintToLayer(false);
-    // Update tabstrip for closed state.
-    LayoutBrowserView(true);
-  }
-}