Adding unit tests for maximize menu

ash/wm/maximize_bubble_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/maximize_bubble_controller.h"
 
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/window_animations.h"
 #include "ash/wm/workspace/frame_maximize_button.h"
@@ skipping 33 matching lines @@
 // The line width of the bubble.
 const int kLineWidth = 1;
 
 // The spacing for the top and bottom of the info label.
 const int kLabelSpacing = 4;
 
 // The pixel dimensions of the arrow.
 const int kArrowHeight = 10;
 const int kArrowWidth = 20;
 
-// The delay of the bubble appearance.
-const int kBubbleAppearanceDelayMS = 200;
-
 // The animation offset in y for the bubble when appearing.
 const int kBubbleAnimationOffsetY = 5;
 
 class MaximizeBubbleBorder : public views::BubbleBorder {
  public:
   MaximizeBubbleBorder(views::View* content_view, views::View* anchor);
 
   virtual ~MaximizeBubbleBorder() {}
 
   // Get the mouse active area of the window.
@@ skipping 144 matching lines @@
 };
 
 // The class which creates and manages the bubble menu element.
 // It creates a 'bubble border' and the content accordingly.
 // Note: Since the SnapSizer will show animations on top of the maximize button
 // this menu gets created as a separate window and the SnapSizer will be
 // created underneath this window.
 class MaximizeBubbleController::Bubble : public views::BubbleDelegateView,
                                          public views::MouseWatcherListener {
  public:
-  explicit Bubble(MaximizeBubbleController* owner);
+  explicit Bubble(MaximizeBubbleController* owner, int appearance_delay_ms_);
   virtual ~Bubble() {}
 
   // The window of the menu under which the SnapSizer will get created.
   aura::Window* GetBubbleWindow();
 
   // Overridden from views::BubbleDelegateView.
   virtual gfx::Rect GetAnchorRect() OVERRIDE;
   virtual void AnimationProgressed(const ui::Animation* animation) OVERRIDE;
 
   // Overridden from views::WidgetDelegateView.
@@ skipping 18 matching lines @@
   virtual void ControllerRequestsCloseAndDelete();
 
   // Called from the owning class to change the menu content to the given
   // |snap_type| so that the user knows what is selected.
   void SetSnapType(SnapType snap_type);
 
   // Get the owning MaximizeBubbleController. This might return NULL in case
   // of an asynchronous shutdown.
   MaximizeBubbleController* controller() const { return owner_; }
 
+  // Added for unit test: Retrieve the button for an action.
+  // |state| can be either SNAP_LEFT, SNAP_RIGHT or SNAP_MINIMIZE.
+  views::CustomButton* GetButtonForUnitTest(SnapType state);
+
  private:
   // True if the shut down has been initiated.
   bool shutting_down_;
 
   // Our owning class.
   MaximizeBubbleController* owner_;
 
   // The widget which contains our menu and the bubble border.
   views::Widget* bubble_widget_;
 
   // The content accessor of the menu.
   BubbleContentsView* contents_view_;
 
   // The bubble border.
   MaximizeBubbleBorder* bubble_border_;
 
   // The rectangle before the animation starts.
   gfx::Rect initial_position_;
 
   // The mouse watcher which takes care of out of window hover events.
   scoped_ptr<views::MouseWatcher> mouse_watcher_;
 
+  // The fade delay - if 0 it will show / hide immediately.
+  const int appearance_delay_ms_;
+
   DISALLOW_COPY_AND_ASSIGN(Bubble);
 };
 
 // A class that creates all buttons and put them into a view.
 class BubbleContentsButtonRow : public views::View,
                                 public views::ButtonListener {
  public:
   explicit BubbleContentsButtonRow(MaximizeBubbleController::Bubble* bubble);
 
   virtual ~BubbleContentsButtonRow() {}
 
   // Overridden from ButtonListener.
   virtual void ButtonPressed(views::Button* sender,
                              const ui::Event& event) OVERRIDE;
   // Called from BubbleDialogButton.
   void ButtonHovered(BubbleDialogButton* sender);
 
+  // Added for unit test: Retrieve the button for an action.
+  // |state| can be either SNAP_LEFT, SNAP_RIGHT or SNAP_MINIMIZE.
+  views::CustomButton* GetButtonForUnitTest(SnapType state);
+
+  MaximizeBubbleController::Bubble* bubble() { return bubble_; }
+
  private:
   // The owning object which gets notifications.
   MaximizeBubbleController::Bubble* bubble_;
 
   // The created buttons for our menu.
   BubbleDialogButton* left_button_;
   BubbleDialogButton* minimize_button_;
   BubbleDialogButton* right_button_;
 
   DISALLOW_COPY_AND_ASSIGN(BubbleContentsButtonRow);
 };
 
 // A class which creates the content of the bubble: The buttons, and the label.
 class BubbleContentsView : public views::View {
  public:
   explicit BubbleContentsView(MaximizeBubbleController::Bubble* bubble);
 
   virtual ~BubbleContentsView() {}
 
   // Set the label content to reflect the currently selected |snap_type|.
   // This function can be executed through the frame maximize button as well as
   // through hover operations.
   void SetSnapType(SnapType snap_type);
 
+  // Added for unit test: Retrieve the button for an action.
+  // |state| can be either SNAP_LEFT, SNAP_RIGHT or SNAP_MINIMIZE.
+  views::CustomButton* GetButtonForUnitTest(SnapType state) {
+    return buttons_view_->GetButtonForUnitTest(state);
+  }
+
  private:
   // The owning class.
   MaximizeBubbleController::Bubble* bubble_;
 
   // The object which owns all the buttons.
   BubbleContentsButtonRow* buttons_view_;
 
   // The label object which shows the user the selected action.
   views::Label* label_view_;
 
   DISALLOW_COPY_AND_ASSIGN(BubbleContentsView);
 };
 
 // The image button gets overridden to be able to capture mouse hover events.
 // The constructor also assigns all button states and
 class BubbleDialogButton : public views::ImageButton {
  public:
   explicit BubbleDialogButton(
       BubbleContentsButtonRow* button_row_listener,
       int normal_image,
       int hovered_image,
       int pressed_image);
   virtual ~BubbleDialogButton() {}
 
   // CustomButton overrides:
   virtual void OnMouseCaptureLost() OVERRIDE;
   virtual void OnMouseEntered(const ui::MouseEvent& event) OVERRIDE;
   virtual void OnMouseExited(const ui::MouseEvent& event) OVERRIDE;
+  virtual bool OnMouseDragged(const ui::MouseEvent& event) OVERRIDE;
 
  private:
   // The creating class which needs to get notified in case of a hover event.
   BubbleContentsButtonRow* button_row_;
 
   DISALLOW_COPY_AND_ASSIGN(BubbleDialogButton);
 };
 
-MaximizeBubbleController::Bubble::Bubble(MaximizeBubbleController* owner)
+MaximizeBubbleController::Bubble::Bubble(
+    MaximizeBubbleController* owner,
+    int appearance_delay_ms)
     : views::BubbleDelegateView(owner->frame_maximize_button(),
                                 views::BubbleBorder::TOP_RIGHT),
       shutting_down_(false),
       owner_(owner),
       bubble_widget_(NULL),
       contents_view_(NULL),
-      bubble_border_(NULL) {
+      bubble_border_(NULL),
+      appearance_delay_ms_(appearance_delay_ms) {
   set_margins(gfx::Insets());
 
   // The window needs to be owned by the root so that the SnapSizer does not
   // cover it upon animation.
   aura::Window* parent = Shell::GetContainer(
       Shell::GetActiveRootWindow(),
       internal::kShellWindowId_LauncherContainer);
   set_parent_window(parent);
 
   set_notify_enter_exit_on_child(true);
@@ skipping 18 matching lines @@
   SetAlignment(views::BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE);
   bubble_widget_->non_client_view()->frame_view()->set_background(NULL);
 
   bubble_border_ = new MaximizeBubbleBorder(this, anchor_view());
   GetBubbleFrameView()->SetBubbleBorder(bubble_border_);
   GetBubbleFrameView()->set_background(NULL);
 
   // Recalculate size with new border.
   SizeToContents();
 
-  StartFade(true);
+  if (!appearance_delay_ms_)
+    Show();
+  else
+    StartFade(true);
 
   mouse_watcher_.reset(new views::MouseWatcher(
       new BubbleMouseWatcherHost(this),
       this));
   mouse_watcher_->Start();
 }
 
 bool BubbleMouseWatcherHost::Contains(
     const gfx::Point& screen_point,
     views::MouseWatcherHost::MouseEventType type) {
@@ skipping 96 matching lines @@
 
 void MaximizeBubbleController::Bubble::ControllerRequestsCloseAndDelete() {
   // This only gets called from the owning base class once it is deleted.
   if (shutting_down_)
     return;
   shutting_down_ = true;
   owner_ = NULL;
 
   // Close the widget asynchronously after the hide animation is finished.
   initial_position_ = bubble_widget_->GetNativeWindow()->bounds();
-  StartFade(false);
+  if (!appearance_delay_ms_)
+    bubble_widget_->CloseNow();
+  else
+    StartFade(false);
 }
 
 void MaximizeBubbleController::Bubble::SetSnapType(SnapType snap_type) {
   if (contents_view_)
     contents_view_->SetSnapType(snap_type);
 }
 
+views::CustomButton* MaximizeBubbleController::Bubble::GetButtonForUnitTest(
+    SnapType state) {
+  return contents_view_->GetButtonForUnitTest(state);
+}
+
 BubbleContentsButtonRow::BubbleContentsButtonRow(
     MaximizeBubbleController::Bubble* bubble)
     : bubble_(bubble),
       left_button_(NULL),
       minimize_button_(NULL),
       right_button_(NULL) {
   SetLayoutManager(new views::BoxLayout(
       views::BoxLayout::kHorizontal, 0, 0, kLayoutSpacing));
   set_background(
       views::Background::CreateSolidBackground(kBubbleBackgroundColor));
@@ skipping 39 matching lines @@
   if (sender == left_button_)
     bubble_->controller()->OnButtonHover(SNAP_LEFT);
   else if (sender == minimize_button_)
     bubble_->controller()->OnButtonHover(SNAP_MINIMIZE);
   else if (sender == right_button_)
     bubble_->controller()->OnButtonHover(SNAP_RIGHT);
   else
     bubble_->controller()->OnButtonHover(SNAP_NONE);
 }
 
+views::CustomButton* BubbleContentsButtonRow::GetButtonForUnitTest(
+    SnapType state) {
+  switch (state) {
+    case SNAP_LEFT:
+      return left_button_;
+    case SNAP_MINIMIZE:
+      return minimize_button_;
+    case SNAP_RIGHT:
+      return right_button_;
+    default:
+      NOTREACHED();
+      return NULL;
+  }
+}
+
 BubbleContentsView::BubbleContentsView(
     MaximizeBubbleController::Bubble* bubble)
     : bubble_(bubble),
       buttons_view_(NULL),
       label_view_(NULL) {
   SetLayoutManager(new views::BoxLayout(
       views::BoxLayout::kVertical, 0, 0, kLayoutSpacing));
   set_background(
       views::Background::CreateSolidBackground(kBubbleBackgroundColor));
 
@@ skipping 41 matching lines @@
       // If nothing is selected, we automatically select the click operation.
       id = bubble_->controller()->is_maximized() ? IDS_ASH_RESTORE_WINDOW :
                IDS_ASH_MAXIMIZE_WINDOW;
       break;
   }
   label_view_->SetText(rb.GetLocalizedString(id));
 }
 
 MaximizeBubbleController::MaximizeBubbleController(
     FrameMaximizeButton* frame_maximize_button,
-    bool is_maximized)
+    bool is_maximized,
+    int appearance_delay_ms)
     : frame_maximize_button_(frame_maximize_button),
       bubble_(NULL),
-      is_maximized_(is_maximized) {
+      is_maximized_(is_maximized),
+      appearance_delay_ms_(appearance_delay_ms) {
   // Create the task which will create the bubble delayed.
   base::OneShotTimer<MaximizeBubbleController>* new_timer =
       new base::OneShotTimer<MaximizeBubbleController>();
+  // Note: Even if there was no delay time given, we need to have a timer.
   new_timer->Start(
       FROM_HERE,
-      base::TimeDelta::FromMilliseconds(kBubbleAppearanceDelayMS),
+      base::TimeDelta::FromMilliseconds(
+          appearance_delay_ms_ ? appearance_delay_ms_ : 10),
       this,
       &MaximizeBubbleController::CreateBubble);
   timer_.reset(new_timer);
+  if (!appearance_delay_ms_)
+    CreateBubble();
 }
 
 MaximizeBubbleController::~MaximizeBubbleController() {
   // Note: The destructor only gets initiated through the owner.
   timer_.reset();
   if (bubble_) {
     bubble_->ControllerRequestsCloseAndDelete();
     bubble_ = NULL;
   }
 }
@@ skipping 13 matching lines @@
 }
 
 void MaximizeBubbleController::OnButtonClicked(SnapType snap_type) {
   frame_maximize_button_->ExecuteSnapAndCloseMenu(snap_type);
 }
 
 void MaximizeBubbleController::OnButtonHover(SnapType snap_type) {
   frame_maximize_button_->SnapButtonHovered(snap_type);
 }
 
+views::CustomButton* MaximizeBubbleController::GetButtonForUnitTest(
+    SnapType state) {
+  return bubble_ ? bubble_->GetButtonForUnitTest(state) : NULL;
+}
+
 void MaximizeBubbleController::RequestDestructionThroughOwner() {
   // Tell the parent to destroy us (if this didn't happen yet).
   if (timer_.get()) {
     timer_.reset(NULL);
     // Informs the owner that the menu is gone and requests |this| destruction.
     frame_maximize_button_->DestroyMaximizeMenu();
     // Note: After this call |this| is destroyed.
   }
 }
 
 void MaximizeBubbleController::CreateBubble() {
   if (!bubble_)
-    bubble_ = new Bubble(this);
+    bubble_ = new Bubble(this, appearance_delay_ms_);
 
   timer_->Stop();
 }
 
 BubbleDialogButton::BubbleDialogButton(
     BubbleContentsButtonRow* button_row,
     int normal_image,
     int hovered_image,
     int pressed_image)
     : views::ImageButton(button_row),
@@ skipping 14 matching lines @@
 void BubbleDialogButton::OnMouseEntered(const ui::MouseEvent& event) {
   button_row_->ButtonHovered(this);
   views::ImageButton::OnMouseEntered(event);
 }
 
 void BubbleDialogButton::OnMouseExited(const ui::MouseEvent& event) {
   button_row_->ButtonHovered(NULL);
   views::ImageButton::OnMouseExited(event);
 }
 
+bool BubbleDialogButton::OnMouseDragged(const ui::MouseEvent& event) {
+  if (!button_row_->bubble()->controller())
+    return false;
+
+  // Remove the phantom window when we leave the button.
+  gfx::Point screen_location(event.location());
+  View::ConvertPointToScreen(this, &screen_location);
+  if (!GetBoundsInScreen().Contains(screen_location))
+    button_row_->ButtonHovered(NULL);
+  else
+    button_row_->ButtonHovered(this);
+
+  // Pass the event on to the normal handler.
+  return views::ImageButton::OnMouseDragged(event);
+}
+
 }  // namespace ash