Refactor PhantomWindowController so that the PhantomWindowController owns the phantom window

ash/wm/workspace/phantom_window_controller.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/wm/workspace/phantom_window_controller.h"
 
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/coordinate_conversion.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
-#include "ui/gfx/animation/slide_animation.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/views/background.h"
 #include "ui/views/painter.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 
 namespace ash {
 namespace internal {
 
+namespace {
+
+// The duration of the show animation.
+const int kAnimationDurationMs = 200;
+
+// Starts an animation of |widget| to |new_bounds_in_screen|. No-op if |widget|
+// is NULL.
+void AnimateToBounds(views::Widget* widget,
+                     const gfx::Rect& new_bounds_in_screen) {
+  if (!widget)
+    return;
+
+  ui::ScopedLayerAnimationSettings scoped_setter(
+      widget->GetNativeWindow()->layer()->GetAnimator());
+  scoped_setter.SetTweenType(gfx::Tween::EASE_IN);
+  scoped_setter.SetPreemptionStrategy(
+      ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+  scoped_setter.SetTransitionDuration(
+      base::TimeDelta::FromMilliseconds(kAnimationDurationMs));
+  widget->SetBounds(new_bounds_in_screen);
+}
+
 // EdgePainter ----------------------------------------------------------------
 
-namespace {
-
 // Paints the background of the phantom window for window snapping.
 class EdgePainter : public views::Painter {
  public:
   EdgePainter();
   virtual ~EdgePainter();
 
   // views::Painter:
   virtual gfx::Size GetMinimumSize() const OVERRIDE;
   virtual void Paint(gfx::Canvas* canvas, const gfx::Size& size) OVERRIDE;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(EdgePainter);
 };
 
-}  // namespace
-
-
 EdgePainter::EdgePainter() {
 }
 
 EdgePainter::~EdgePainter() {
 }
 
 gfx::Size EdgePainter::GetMinimumSize() const {
   return gfx::Size();
 }
 
@@ skipping 22 matching lines @@
     return;
 
   paint.setColor(SkColorSetARGB(200, 255, 255, 255));
   paint.setStyle(SkPaint::kStroke_Style);
   paint.setStrokeWidth(SkIntToScalar(2));
   canvas->sk_canvas()->drawRoundRect(
       gfx::RectToSkRect(gfx::Rect(x, y, w, h)), SkIntToScalar(kRoundRectSize),
       SkIntToScalar(kRoundRectSize), paint);
 }
 
+}  // namespace
 
 // PhantomWindowController ----------------------------------------------------
 
 PhantomWindowController::PhantomWindowController(aura::Window* window)
     : window_(window),
-      phantom_below_window_(NULL),
-      phantom_widget_(NULL),
-      phantom_widget_start_(NULL) {
+      phantom_below_window_(NULL) {
 }
 
 PhantomWindowController::~PhantomWindowController() {
-  Hide();
 }
 
 void PhantomWindowController::Show(const gfx::Rect& bounds_in_screen) {
-  if (bounds_in_screen == bounds_in_screen_)
+  if (bounds_in_screen == target_bounds_in_screen_)
     return;
-  bounds_in_screen_ = bounds_in_screen;
-  aura::Window* target_root = wm::GetRootWindowMatching(bounds_in_screen);
-  // Show the phantom at the current bounds of the window. We'll animate to the
-  // target bounds. If phantom exists, update the start bounds.
-  if (!phantom_widget_)
-    start_bounds_ = window_->GetBoundsInScreen();
-  else
-    start_bounds_ = phantom_widget_->GetWindowBoundsInScreen();
-  if (phantom_widget_ &&
-      phantom_widget_->GetNativeWindow()->GetRootWindow() != target_root) {
-    phantom_widget_->Close();
-    phantom_widget_ = NULL;
+  target_bounds_in_screen_ = bounds_in_screen;
+
+  gfx::Rect start_bounds_in_screen;
+  if (!phantom_widget_in_target_root_) {
+    start_bounds_in_screen = window_->GetBoundsInScreen();
+  } else {
+    start_bounds_in_screen =
+        phantom_widget_in_target_root_->GetWindowBoundsInScreen();
   }
-  if (!phantom_widget_)
-    phantom_widget_ = CreatePhantomWidget(target_root, start_bounds_);
 
-  // Create a secondary widget in a second screen if start_bounds_ lie at least
-  // partially in that other screen. This allows animations to start or restart
-  // in one root window and progress into another root.
-  aura::Window* start_root = wm::GetRootWindowMatching(start_bounds_);
+  aura::Window* target_root =
+      wm::GetRootWindowMatching(target_bounds_in_screen_);
+  if (!phantom_widget_in_target_root_ ||
+      phantom_widget_in_target_root_->GetNativeWindow()->GetRootWindow() !=
+          target_root) {
+    phantom_widget_in_target_root_ =
+        CreatePhantomWidget(target_root, start_bounds_in_screen);
+  }
+  AnimateToBounds(phantom_widget_in_target_root_.get(),
+                  target_bounds_in_screen_);
+
+  // Create a secondary widget in a second screen if |start_bounds_in_screen|
+  // lies at least partially in another screen. This allows animations to start
+  // or restart in one root window and progress to another root.
+  aura::Window* start_root = wm::GetRootWindowMatching(start_bounds_in_screen);
   if (start_root == target_root) {
     aura::Window::Windows root_windows = Shell::GetAllRootWindows();
     for (size_t i = 0; i < root_windows.size(); ++i) {
       if (root_windows[i] != target_root &&
-          root_windows[i]->GetBoundsInScreen().Intersects(start_bounds_)) {
+          root_windows[i]->GetBoundsInScreen().Intersects(
+              start_bounds_in_screen)) {
         start_root = root_windows[i];
         break;
       }
     }
   }
-  if (phantom_widget_start_ &&
-      (phantom_widget_start_->GetNativeWindow()->GetRootWindow() != start_root
-       || start_root == target_root)) {
-    phantom_widget_start_->Close();
-    phantom_widget_start_ = NULL;
+  if (start_root == target_root) {
+    phantom_widget_in_start_root_.reset();
+  } else {
+    if (!phantom_widget_in_start_root_ ||
+        phantom_widget_in_start_root_->GetNativeWindow()->GetRootWindow() !=
+            start_root) {
+      phantom_widget_in_start_root_ =
+          CreatePhantomWidget(start_root, start_bounds_in_screen);
+    }
+    AnimateToBounds(phantom_widget_in_start_root_.get(),
+                    target_bounds_in_screen_);
   }
-  if (!phantom_widget_start_ && start_root != target_root)
-    phantom_widget_start_ = CreatePhantomWidget(start_root, start_bounds_);
-
-  animation_.reset(new gfx::SlideAnimation(this));
-  animation_->SetTweenType(gfx::Tween::EASE_IN);
-  const int kAnimationDurationMS = 200;
-  animation_->SetSlideDuration(kAnimationDurationMS);
-  animation_->Show();
 }
 
-void PhantomWindowController::Hide() {
-  if (phantom_widget_)
-    phantom_widget_->Close();
-  phantom_widget_ = NULL;
-  if (phantom_widget_start_)
-    phantom_widget_start_->Close();
-  phantom_widget_start_ = NULL;
-}
-
-bool PhantomWindowController::IsShowing() const {
-  return phantom_widget_ != NULL;
-}
-
-void PhantomWindowController::AnimationProgressed(
-    const gfx::Animation* animation) {
-  const gfx::Rect current_bounds =
-      animation->CurrentValueBetween(start_bounds_, bounds_in_screen_);
-  if (phantom_widget_start_)
-    phantom_widget_start_->SetBounds(current_bounds);
-  phantom_widget_->SetBounds(current_bounds);
-}
-
-views::Widget* PhantomWindowController::CreatePhantomWidget(
+scoped_ptr<views::Widget> PhantomWindowController::CreatePhantomWidget(
     aura::Window* root_window,
     const gfx::Rect& bounds_in_screen) {
-  views::Widget* phantom_widget = new views::Widget;
+  scoped_ptr<views::Widget> phantom_widget(new views::Widget);
   views::Widget::InitParams params(views::Widget::InitParams::TYPE_POPUP);
   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
   // PhantomWindowController is used by FrameMaximizeButton to highlight the
   // launcher button. Put the phantom in the same window as the launcher so that
   // the phantom is visible.
   params.parent = Shell::GetContainer(root_window,
                                       kShellWindowId_ShelfContainer);
   params.can_activate = false;
   params.keep_on_top = true;
+  params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   phantom_widget->set_focus_on_creation(false);
   phantom_widget->Init(params);
   phantom_widget->SetVisibilityChangedAnimationsEnabled(false);
   phantom_widget->GetNativeWindow()->SetName("PhantomWindow");
   phantom_widget->GetNativeWindow()->set_id(kShellWindowId_PhantomWindow);
   views::View* content_view = new views::View;
   content_view->set_background(
       views::Background::CreateBackgroundPainter(true, new EdgePainter));
   phantom_widget->SetContentsView(content_view);
   phantom_widget->SetBounds(bounds_in_screen);
   if (phantom_below_window_)
     phantom_widget->StackBelow(phantom_below_window_);
   else
     phantom_widget->StackAbove(window_);
 
   // Show the widget after all the setups.
   phantom_widget->Show();
 
   // Fade the window in.
   ui::Layer* widget_layer = phantom_widget->GetNativeWindow()->layer();
   widget_layer->SetOpacity(0);
   ui::ScopedLayerAnimationSettings scoped_setter(widget_layer->GetAnimator());
+  scoped_setter.SetTransitionDuration(
+      base::TimeDelta::FromMilliseconds(kAnimationDurationMs));
   widget_layer->SetOpacity(1);
-  return phantom_widget;
+
+  return phantom_widget.Pass();
 }
 
 }  // namespace internal
 }  // namespace ash