src/ash/wm/toplevel_window_event_handler.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ash/wm/toplevel_window_event_handler.h"
   6
   7 #include "ash/shell.h"
   8 #include "ash/wm/resize_shadow_controller.h"
   9 #include "ash/wm/window_resizer.h"
  10 #include "ash/wm/window_state.h"
  11 #include "ash/wm/window_state_observer.h"
  12 #include "ash/wm/window_util.h"
  13 #include "ash/wm/wm_event.h"
  14 #include "base/message_loop/message_loop.h"
  15 #include "base/run_loop.h"
  16 #include "ui/aura/client/cursor_client.h"
  17 #include "ui/aura/env.h"
  18 #include "ui/aura/window.h"
  19 #include "ui/aura/window_delegate.h"
  20 #include "ui/aura/window_event_dispatcher.h"
  21 #include "ui/aura/window_observer.h"
  22 #include "ui/aura/window_tree_host.h"
  23 #include "ui/base/cursor/cursor.h"
  24 #include "ui/base/hit_test.h"
  25 #include "ui/base/ui_base_types.h"
  26 #include "ui/events/event.h"
  27 #include "ui/events/event_utils.h"
  28 #include "ui/events/gestures/gesture_recognizer.h"
  29 #include "ui/gfx/geometry/point_conversions.h"
  30 #include "ui/gfx/screen.h"
  31
  32 namespace {
  33 const double kMinHorizVelocityForWindowSwipe = 1100;
  34 const double kMinVertVelocityForWindowMinimize = 1000;
  35 }
  36
  37 namespace ash {
  38
  39 namespace {
  40
  41 // Returns whether |window| can be moved via a two finger drag given
  42 // the hittest results of the two fingers.
  43 bool CanStartTwoFingerMove(aura::Window* window,
  44                            int window_component1,
  45                            int window_component2) {
  46   // We allow moving a window via two fingers when the hittest components are
  47   // HTCLIENT. This is done so that a window can be dragged via two fingers when
  48   // the tab strip is full and hitting the caption area is difficult. We check
  49   // the window type and the state type so that we do not steal touches from the
  50   // web contents.
  51   if (!wm::GetWindowState(window)->IsNormalOrSnapped() ||
  52       window->type() != ui::wm::WINDOW_TYPE_NORMAL) {
  53     return false;
  54   }
  55   int component1_behavior =
  56       WindowResizer::GetBoundsChangeForWindowComponent(window_component1);
  57   int component2_behavior =
  58       WindowResizer::GetBoundsChangeForWindowComponent(window_component2);
  59   return (component1_behavior & WindowResizer::kBoundsChange_Resizes) == 0 &&
  60       (component2_behavior & WindowResizer::kBoundsChange_Resizes) == 0;
  61 }
  62
  63 // Returns whether |window| can be moved or resized via one finger given
  64 // |window_component|.
  65 bool CanStartOneFingerDrag(int window_component) {
  66   return WindowResizer::GetBoundsChangeForWindowComponent(
  67       window_component) != 0;
  68 }
  69
  70 gfx::Point ConvertPointToParent(aura::Window* window,
  71                                 const gfx::Point& point) {
  72   gfx::Point result(point);
  73   aura::Window::ConvertPointToTarget(window, window->parent(), &result);
  74   return result;
  75 }
  76
  77 // Returns the window component containing |event|'s location.
  78 int GetWindowComponent(aura::Window* window, const ui::LocatedEvent& event) {
  79   return window->delegate()->GetNonClientComponent(event.location());
  80 }
  81
  82 }  // namespace
  83
  84 // ScopedWindowResizer ---------------------------------------------------------
  85
  86 // Wraps a WindowResizer and installs an observer on its target window.  When
  87 // the window is destroyed ResizerWindowDestroyed() is invoked back on the
  88 // ToplevelWindowEventHandler to clean up.
  89 class ToplevelWindowEventHandler::ScopedWindowResizer
  90     : public aura::WindowObserver,
  91       public wm::WindowStateObserver {
  92  public:
  93   ScopedWindowResizer(ToplevelWindowEventHandler* handler,
  94                       WindowResizer* resizer);
  95   virtual ~ScopedWindowResizer();
  96
  97   // Returns true if the drag moves the window and does not resize.
  98   bool IsMove() const;
  99
 100   WindowResizer* resizer() { return resizer_.get(); }
 101
 102   // WindowObserver overrides:
 103   virtual void OnWindowDestroying(aura::Window* window) OVERRIDE;
 104
 105   // WindowStateObserver overrides:
 106   virtual void OnPreWindowStateTypeChange(wm::WindowState* window_state,
 107                                           wm::WindowStateType type) OVERRIDE;
 108
 109  private:
 110   ToplevelWindowEventHandler* handler_;
 111   scoped_ptr<WindowResizer> resizer_;
 112
 113   DISALLOW_COPY_AND_ASSIGN(ScopedWindowResizer);
 114 };
 115
 116 ToplevelWindowEventHandler::ScopedWindowResizer::ScopedWindowResizer(
 117     ToplevelWindowEventHandler* handler,
 118     WindowResizer* resizer)
 119     : handler_(handler),
 120       resizer_(resizer) {
 121   resizer_->GetTarget()->AddObserver(this);
 122   wm::GetWindowState(resizer_->GetTarget())->AddObserver(this);
 123 }
 124
 125 ToplevelWindowEventHandler::ScopedWindowResizer::~ScopedWindowResizer() {
 126   resizer_->GetTarget()->RemoveObserver(this);
 127   wm::GetWindowState(resizer_->GetTarget())->RemoveObserver(this);
 128 }
 129
 130 bool ToplevelWindowEventHandler::ScopedWindowResizer::IsMove() const {
 131   return resizer_->details().bounds_change ==
 132       WindowResizer::kBoundsChange_Repositions;
 133 }
 134
 135 void
 136 ToplevelWindowEventHandler::ScopedWindowResizer::OnPreWindowStateTypeChange(
 137     wm::WindowState* window_state,
 138     wm::WindowStateType old) {
 139   handler_->CompleteDrag(DRAG_COMPLETE);
 140 }
 141
 142 void ToplevelWindowEventHandler::ScopedWindowResizer::OnWindowDestroying(
 143     aura::Window* window) {
 144   DCHECK_EQ(resizer_->GetTarget(), window);
 145   handler_->ResizerWindowDestroyed();
 146 }
 147
 148 // ToplevelWindowEventHandler --------------------------------------------------
 149
 150 ToplevelWindowEventHandler::ToplevelWindowEventHandler()
 151     : first_finger_hittest_(HTNOWHERE),
 152       in_move_loop_(false),
 153       in_gesture_drag_(false),
 154       drag_reverted_(false),
 155       destroyed_(NULL) {
 156   Shell::GetInstance()->display_controller()->AddObserver(this);
 157 }
 158
 159 ToplevelWindowEventHandler::~ToplevelWindowEventHandler() {
 160   Shell::GetInstance()->display_controller()->RemoveObserver(this);
 161   if (destroyed_)
 162     *destroyed_ = true;
 163 }
 164
 165 void ToplevelWindowEventHandler::OnKeyEvent(ui::KeyEvent* event) {
 166   if (window_resizer_.get() && event->type() == ui::ET_KEY_PRESSED &&
 167       event->key_code() == ui::VKEY_ESCAPE) {
 168     CompleteDrag(DRAG_REVERT);
 169   }
 170 }
 171
 172 void ToplevelWindowEventHandler::OnMouseEvent(
 173     ui::MouseEvent* event) {
 174   if (event->handled())
 175     return;
 176   if ((event->flags() &
 177       (ui::EF_MIDDLE_MOUSE_BUTTON | ui::EF_RIGHT_MOUSE_BUTTON)) != 0)
 178     return;
 179
 180   if (in_gesture_drag_)
 181     return;
 182
 183   aura::Window* target = static_cast<aura::Window*>(event->target());
 184   switch (event->type()) {
 185     case ui::ET_MOUSE_PRESSED:
 186       HandleMousePressed(target, event);
 187       break;
 188     case ui::ET_MOUSE_DRAGGED:
 189       HandleDrag(target, event);
 190       break;
 191     case ui::ET_MOUSE_CAPTURE_CHANGED:
 192     case ui::ET_MOUSE_RELEASED:
 193       HandleMouseReleased(target, event);
 194       break;
 195     case ui::ET_MOUSE_MOVED:
 196       HandleMouseMoved(target, event);
 197       break;
 198     case ui::ET_MOUSE_EXITED:
 199       HandleMouseExited(target, event);
 200       break;
 201     default:
 202       break;
 203   }
 204 }
 205
 206 void ToplevelWindowEventHandler::OnGestureEvent(ui::GestureEvent* event) {
 207   if (event->handled())
 208     return;
 209   aura::Window* target = static_cast<aura::Window*>(event->target());
 210   if (!target->delegate())
 211     return;
 212
 213   if (window_resizer_.get() && !in_gesture_drag_)
 214     return;
 215
 216   if (window_resizer_.get() &&
 217       window_resizer_->resizer()->GetTarget() != target) {
 218     return;
 219   }
 220
 221   if (event->details().touch_points() > 2) {
 222     if (window_resizer_.get()) {
 223       CompleteDrag(DRAG_COMPLETE);
 224       event->StopPropagation();
 225     }
 226     return;
 227   }
 228
 229   switch (event->type()) {
 230     case ui::ET_GESTURE_TAP_DOWN: {
 231       int component = GetWindowComponent(target, *event);
 232       if (!(WindowResizer::GetBoundsChangeForWindowComponent(component) &
 233             WindowResizer::kBoundsChange_Resizes))
 234         return;
 235       ResizeShadowController* controller =
 236           Shell::GetInstance()->resize_shadow_controller();
 237       if (controller)
 238         controller->ShowShadow(target, component);
 239       return;
 240     }
 241     case ui::ET_GESTURE_END: {
 242       ResizeShadowController* controller =
 243           Shell::GetInstance()->resize_shadow_controller();
 244       if (controller)
 245         controller->HideShadow(target);
 246
 247       if (window_resizer_.get() &&
 248           (event->details().touch_points() == 1 ||
 249            !CanStartOneFingerDrag(first_finger_hittest_))) {
 250         CompleteDrag(DRAG_COMPLETE);
 251         event->StopPropagation();
 252       }
 253       return;
 254     }
 255     case ui::ET_GESTURE_BEGIN: {
 256       if (event->details().touch_points() == 1) {
 257         first_finger_hittest_ = GetWindowComponent(target, *event);
 258       } else if (window_resizer_.get()) {
 259         if (!window_resizer_->IsMove()) {
 260           // The transition from resizing with one finger to resizing with two
 261           // fingers causes unintended resizing because the location of
 262           // ET_GESTURE_SCROLL_UPDATE jumps from the position of the first
 263           // finger to the position in the middle of the two fingers. For this
 264           // reason two finger resizing is not supported.
 265           CompleteDrag(DRAG_COMPLETE);
 266           event->StopPropagation();
 267         }
 268       } else {
 269         int second_finger_hittest = GetWindowComponent(target, *event);
 270         if (CanStartTwoFingerMove(
 271                 target, first_finger_hittest_, second_finger_hittest)) {
 272           gfx::Point location_in_parent =
 273               event->details().bounding_box().CenterPoint();
 274           AttemptToStartDrag(target, location_in_parent, HTCAPTION,
 275                              aura::client::WINDOW_MOVE_SOURCE_TOUCH);
 276           event->StopPropagation();
 277         }
 278       }
 279       return;
 280     }
 281     case ui::ET_GESTURE_SCROLL_BEGIN: {
 282       // The one finger drag is not started in ET_GESTURE_BEGIN to avoid the
 283       // window jumping upon initiating a two finger drag. When a one finger
 284       // drag is converted to a two finger drag, a jump occurs because the
 285       // location of the ET_GESTURE_SCROLL_UPDATE event switches from the single
 286       // finger's position to the position in the middle of the two fingers.
 287       if (window_resizer_.get())
 288         return;
 289       int component = GetWindowComponent(target, *event);
 290       if (!CanStartOneFingerDrag(component))
 291         return;
 292       gfx::Point location_in_parent(
 293           ConvertPointToParent(target, event->location()));
 294       AttemptToStartDrag(target, location_in_parent, component,
 295                          aura::client::WINDOW_MOVE_SOURCE_TOUCH);
 296       event->StopPropagation();
 297       return;
 298     }
 299     default:
 300       break;
 301   }
 302
 303   if (!window_resizer_.get())
 304     return;
 305
 306   switch (event->type()) {
 307     case ui::ET_GESTURE_SCROLL_UPDATE:
 308       HandleDrag(target, event);
 309       event->StopPropagation();
 310       return;
 311     case ui::ET_GESTURE_SCROLL_END:
 312       // We must complete the drag here instead of as a result of ET_GESTURE_END
 313       // because otherwise the drag will be reverted when EndMoveLoop() is
 314       // called.
 315       // TODO(pkotwicz): Pass drag completion status to
 316       // WindowMoveClient::EndMoveLoop().
 317       CompleteDrag(DRAG_COMPLETE);
 318       event->StopPropagation();
 319       return;
 320     case ui::ET_SCROLL_FLING_START:
 321       CompleteDrag(DRAG_COMPLETE);
 322
 323       // TODO(pkotwicz): Fix tests which inadvertantly start flings and check
 324       // window_resizer_->IsMove() instead of the hittest component at |event|'s
 325       // location.
 326       if (GetWindowComponent(target, *event) != HTCAPTION ||
 327           !wm::GetWindowState(target)->IsNormalOrSnapped()) {
 328         return;
 329       }
 330
 331       if (event->details().velocity_y() > kMinVertVelocityForWindowMinimize) {
 332         SetWindowStateTypeFromGesture(target, wm::WINDOW_STATE_TYPE_MINIMIZED);
 333       } else if (event->details().velocity_y() <
 334                  -kMinVertVelocityForWindowMinimize) {
 335         SetWindowStateTypeFromGesture(target, wm::WINDOW_STATE_TYPE_MAXIMIZED);
 336       } else if (event->details().velocity_x() >
 337                  kMinHorizVelocityForWindowSwipe) {
 338         SetWindowStateTypeFromGesture(target,
 339                                       wm::WINDOW_STATE_TYPE_RIGHT_SNAPPED);
 340       } else if (event->details().velocity_x() <
 341                  -kMinHorizVelocityForWindowSwipe) {
 342         SetWindowStateTypeFromGesture(target,
 343                                       wm::WINDOW_STATE_TYPE_LEFT_SNAPPED);
 344       }
 345       event->StopPropagation();
 346       return;
 347     case ui::ET_GESTURE_SWIPE:
 348       DCHECK_GT(event->details().touch_points(), 0);
 349       if (event->details().touch_points() == 1)
 350         return;
 351       if (!wm::GetWindowState(target)->IsNormalOrSnapped())
 352         return;
 353
 354       CompleteDrag(DRAG_COMPLETE);
 355
 356       if (event->details().swipe_down()) {
 357         SetWindowStateTypeFromGesture(target, wm::WINDOW_STATE_TYPE_MINIMIZED);
 358       } else if (event->details().swipe_up()) {
 359         SetWindowStateTypeFromGesture(target, wm::WINDOW_STATE_TYPE_MAXIMIZED);
 360       } else if (event->details().swipe_right()) {
 361         SetWindowStateTypeFromGesture(target,
 362                                       wm::WINDOW_STATE_TYPE_RIGHT_SNAPPED);
 363       } else {
 364         SetWindowStateTypeFromGesture(target,
 365                                       wm::WINDOW_STATE_TYPE_LEFT_SNAPPED);
 366       }
 367       event->StopPropagation();
 368       return;
 369     default:
 370       return;
 371   }
 372 }
 373
 374 aura::client::WindowMoveResult ToplevelWindowEventHandler::RunMoveLoop(
 375     aura::Window* source,
 376     const gfx::Vector2d& drag_offset,
 377     aura::client::WindowMoveSource move_source) {
 378   DCHECK(!in_move_loop_);  // Can only handle one nested loop at a time.
 379   aura::Window* root_window = source->GetRootWindow();
 380   DCHECK(root_window);
 381   // TODO(tdresser): Use gfx::PointF. See crbug.com/337824.
 382   gfx::Point drag_location;
 383   if (move_source == aura::client::WINDOW_MOVE_SOURCE_TOUCH &&
 384       aura::Env::GetInstance()->is_touch_down()) {
 385     gfx::PointF drag_location_f;
 386     bool has_point = ui::GestureRecognizer::Get()->
 387         GetLastTouchPointForTarget(source, &drag_location_f);
 388     drag_location = gfx::ToFlooredPoint(drag_location_f);
 389     DCHECK(has_point);
 390   } else {
 391     drag_location =
 392         root_window->GetHost()->dispatcher()->GetLastMouseLocationInRoot();
 393     aura::Window::ConvertPointToTarget(
 394         root_window, source->parent(), &drag_location);
 395   }
 396   // Set the cursor before calling AttemptToStartDrag(), as that will
 397   // eventually call LockCursor() and prevent the cursor from changing.
 398   aura::client::CursorClient* cursor_client =
 399       aura::client::GetCursorClient(root_window);
 400   if (cursor_client)
 401     cursor_client->SetCursor(ui::kCursorPointer);
 402   if (!AttemptToStartDrag(source, drag_location, HTCAPTION, move_source))
 403     return aura::client::MOVE_CANCELED;
 404
 405   in_move_loop_ = true;
 406   bool destroyed = false;
 407   destroyed_ = &destroyed;
 408   base::MessageLoopForUI* loop = base::MessageLoopForUI::current();
 409   base::MessageLoop::ScopedNestableTaskAllower allow_nested(loop);
 410   base::RunLoop run_loop;
 411   quit_closure_ = run_loop.QuitClosure();
 412   run_loop.Run();
 413   if (destroyed)
 414     return aura::client::MOVE_CANCELED;
 415   destroyed_ = NULL;
 416   in_move_loop_ = false;
 417   return drag_reverted_ ? aura::client::MOVE_CANCELED :
 418       aura::client::MOVE_SUCCESSFUL;
 419 }
 420
 421 void ToplevelWindowEventHandler::EndMoveLoop() {
 422   if (in_move_loop_)
 423     CompleteDrag(DRAG_REVERT);
 424 }
 425
 426 void ToplevelWindowEventHandler::OnDisplayConfigurationChanging() {
 427   CompleteDrag(DRAG_REVERT);
 428 }
 429
 430 bool ToplevelWindowEventHandler::AttemptToStartDrag(
 431     aura::Window* window,
 432     const gfx::Point& point_in_parent,
 433     int window_component,
 434     aura::client::WindowMoveSource source) {
 435   if (window_resizer_.get())
 436     return false;
 437   WindowResizer* resizer = CreateWindowResizer(window, point_in_parent,
 438       window_component, source).release();
 439   if (!resizer)
 440     return false;
 441
 442   window_resizer_.reset(new ScopedWindowResizer(this, resizer));
 443
 444   pre_drag_window_bounds_ = window->bounds();
 445   in_gesture_drag_ = (source == aura::client::WINDOW_MOVE_SOURCE_TOUCH);
 446   return true;
 447 }
 448
 449 void ToplevelWindowEventHandler::CompleteDrag(DragCompletionStatus status) {
 450   scoped_ptr<ScopedWindowResizer> resizer(window_resizer_.release());
 451   if (resizer) {
 452     if (status == DRAG_COMPLETE)
 453       resizer->resizer()->CompleteDrag();
 454     else
 455       resizer->resizer()->RevertDrag();
 456   }
 457   drag_reverted_ = (status == DRAG_REVERT);
 458
 459   first_finger_hittest_ = HTNOWHERE;
 460   in_gesture_drag_ = false;
 461   if (in_move_loop_)
 462     quit_closure_.Run();
 463 }
 464
 465 void ToplevelWindowEventHandler::HandleMousePressed(
 466     aura::Window* target,
 467     ui::MouseEvent* event) {
 468   if (event->phase() != ui::EP_PRETARGET || !target->delegate())
 469     return;
 470
 471   // We also update the current window component here because for the
 472   // mouse-drag-release-press case, where the mouse is released and
 473   // pressed without mouse move event.
 474   int component = GetWindowComponent(target, *event);
 475   if ((event->flags() &
 476         (ui::EF_IS_DOUBLE_CLICK | ui::EF_IS_TRIPLE_CLICK)) == 0 &&
 477       WindowResizer::GetBoundsChangeForWindowComponent(component)) {
 478     gfx::Point location_in_parent(
 479         ConvertPointToParent(target, event->location()));
 480     AttemptToStartDrag(target, location_in_parent, component,
 481                        aura::client::WINDOW_MOVE_SOURCE_MOUSE);
 482     // Set as handled so that other event handlers do no act upon the event
 483     // but still receive it so that they receive both parts of each pressed/
 484     // released pair.
 485     event->SetHandled();
 486   } else {
 487     CompleteDrag(DRAG_COMPLETE);
 488   }
 489 }
 490
 491 void ToplevelWindowEventHandler::HandleMouseReleased(
 492     aura::Window* target,
 493     ui::MouseEvent* event) {
 494   if (event->phase() != ui::EP_PRETARGET)
 495     return;
 496
 497   CompleteDrag(event->type() == ui::ET_MOUSE_RELEASED ?
 498                    DRAG_COMPLETE : DRAG_REVERT);
 499   // Completing the drag may result in hiding the window. If this happens
 500   // mark the event as handled so no other handlers/observers act upon the
 501   // event. They should see the event on a hidden window, to determine targets
 502   // of destructive actions such as hiding. They should not act upon them.
 503   if (window_resizer_ &&
 504       event->type() == ui::ET_MOUSE_CAPTURE_CHANGED &&
 505       !target->IsVisible()) {
 506     event->SetHandled();
 507   }
 508 }
 509
 510 void ToplevelWindowEventHandler::HandleDrag(
 511     aura::Window* target,
 512     ui::LocatedEvent* event) {
 513   // This function only be triggered to move window
 514   // by mouse drag or touch move event.
 515   DCHECK(event->type() == ui::ET_MOUSE_DRAGGED ||
 516          event->type() == ui::ET_TOUCH_MOVED ||
 517          event->type() == ui::ET_GESTURE_SCROLL_UPDATE);
 518
 519   // Drag actions are performed pre-target handling to prevent spurious mouse
 520   // moves from the move/size operation from being sent to the target.
 521   if (event->phase() != ui::EP_PRETARGET)
 522     return;
 523
 524   if (!window_resizer_)
 525     return;
 526   window_resizer_->resizer()->Drag(
 527       ConvertPointToParent(target, event->location()), event->flags());
 528   event->StopPropagation();
 529 }
 530
 531 void ToplevelWindowEventHandler::HandleMouseMoved(
 532     aura::Window* target,
 533     ui::LocatedEvent* event) {
 534   // Shadow effects are applied after target handling. Note that we don't
 535   // respect ER_HANDLED here right now since we have not had a reason to allow
 536   // the target to cancel shadow rendering.
 537   if (event->phase() != ui::EP_POSTTARGET || !target->delegate())
 538     return;
 539
 540   // TODO(jamescook): Move the resize cursor update code into here from
 541   // CompoundEventFilter?
 542   ResizeShadowController* controller =
 543       Shell::GetInstance()->resize_shadow_controller();
 544   if (controller) {
 545     if (event->flags() & ui::EF_IS_NON_CLIENT) {
 546       int component =
 547           target->delegate()->GetNonClientComponent(event->location());
 548       controller->ShowShadow(target, component);
 549     } else {
 550       controller->HideShadow(target);
 551     }
 552   }
 553 }
 554
 555 void ToplevelWindowEventHandler::HandleMouseExited(
 556     aura::Window* target,
 557     ui::LocatedEvent* event) {
 558   // Shadow effects are applied after target handling. Note that we don't
 559   // respect ER_HANDLED here right now since we have not had a reason to allow
 560   // the target to cancel shadow rendering.
 561   if (event->phase() != ui::EP_POSTTARGET)
 562     return;
 563
 564   ResizeShadowController* controller =
 565       Shell::GetInstance()->resize_shadow_controller();
 566   if (controller)
 567     controller->HideShadow(target);
 568 }
 569
 570 void ToplevelWindowEventHandler::SetWindowStateTypeFromGesture(
 571     aura::Window* window,
 572     wm::WindowStateType new_state_type) {
 573   wm::WindowState* window_state = ash::wm::GetWindowState(window);
 574   // TODO(oshima): Move extra logic (set_unminimize_to_restore_bounds,
 575   // SetRestoreBoundsInParent) that modifies the window state
 576   // into WindowState.
 577   switch (new_state_type) {
 578     case wm::WINDOW_STATE_TYPE_MINIMIZED:
 579       if (window_state->CanMinimize()) {
 580         window_state->Minimize();
 581         window_state->set_unminimize_to_restore_bounds(true);
 582         window_state->SetRestoreBoundsInParent(pre_drag_window_bounds_);
 583       }
 584       break;
 585     case wm::WINDOW_STATE_TYPE_MAXIMIZED:
 586       if (window_state->CanMaximize()) {
 587         window_state->SetRestoreBoundsInParent(pre_drag_window_bounds_);
 588         window_state->Maximize();
 589       }
 590       break;
 591     case wm::WINDOW_STATE_TYPE_LEFT_SNAPPED:
 592       if (window_state->CanSnap()) {
 593         window_state->SetRestoreBoundsInParent(pre_drag_window_bounds_);
 594         const wm::WMEvent event(wm::WM_EVENT_SNAP_LEFT);
 595         window_state->OnWMEvent(&event);
 596       }
 597       break;
 598     case wm::WINDOW_STATE_TYPE_RIGHT_SNAPPED:
 599       if (window_state->CanSnap()) {
 600         window_state->SetRestoreBoundsInParent(pre_drag_window_bounds_);
 601         const wm::WMEvent event(wm::WM_EVENT_SNAP_RIGHT);
 602         window_state->OnWMEvent(&event);
 603       }
 604       break;
 605     default:
 606       NOTREACHED();
 607   }
 608 }
 609
 610 void ToplevelWindowEventHandler::ResizerWindowDestroyed() {
 611   // We explicitly don't invoke RevertDrag() since that may do things to window.
 612   // Instead we destroy the resizer.
 613   window_resizer_.reset();
 614
 615   CompleteDrag(DRAG_REVERT);
 616 }
 617
 618 }  // namespace ash