Separate the logic of popup alignment and workarea handling as delegate.

ui/message_center/views/message_popup_collection.cc

 // Copyright (c) 2013 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 "ui/message_center/views/message_popup_collection.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "ui/accessibility/ax_enums.h"
 #include "ui/gfx/animation/animation_delegate.h"
 #include "ui/gfx/animation/slide_animation.h"
 #include "ui/gfx/screen.h"
 #include "ui/message_center/message_center.h"
 #include "ui/message_center/message_center_style.h"
 #include "ui/message_center/message_center_tray.h"
 #include "ui/message_center/notification.h"
 #include "ui/message_center/notification_list.h"
 #include "ui/message_center/views/message_view_context_menu_controller.h"
 #include "ui/message_center/views/notification_view.h"
+#include "ui/message_center/views/popup_alignment_delegate.h"
 #include "ui/message_center/views/toast_contents_view.h"
 #include "ui/views/background.h"
 #include "ui/views/layout/fill_layout.h"
 #include "ui/views/view.h"
 #include "ui/views/views_delegate.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 
 namespace message_center {
 namespace {
 
 // Timeout between the last user-initiated close of the toast and the moment
 // when normal layout/update of the toast stack continues. If the last toast was
 // just closed, the timeout is shorter.
 const int kMouseExitedDeferTimeoutMs = 200;
 
 // The margin between messages (and between the anchor unless
 // first_item_has_no_margin was specified).
 const int kToastMarginY = kMarginBetweenItems;
-#if defined(OS_CHROMEOS)
-const int kToastMarginX = 3;
-#else
-const int kToastMarginX = kMarginBetweenItems;
-#endif
-
-
-// If there should be no margin for the first item, this value needs to be
-// substracted to flush the message to the shelf (the width of the border +
-// shadow).
-const int kNoToastMarginBorderAndShadowOffset = 2;
 
 }  // namespace.
 
-MessagePopupCollection::MessagePopupCollection(gfx::NativeView parent,
-                                               MessageCenter* message_center,
-                                               MessageCenterTray* tray,
-                                               bool first_item_has_no_margin)
+MessagePopupCollection::MessagePopupCollection(
+    gfx::NativeView parent,
+    MessageCenter* message_center,
+    MessageCenterTray* tray,
+    PopupAlignmentDelegate* alignment_delegate)
     : parent_(parent),
       message_center_(message_center),
       tray_(tray),
-      display_id_(gfx::Display::kInvalidDisplayID),
-      screen_(NULL),
+      alignment_delegate_(alignment_delegate),
       defer_counter_(0),
       latest_toast_entered_(NULL),
       user_is_closing_toasts_by_clicking_(false),
-      first_item_has_no_margin_(first_item_has_no_margin),
       context_menu_controller_(new MessageViewContextMenuController(this)),
       weak_factory_(this) {
   DCHECK(message_center_);
   defer_timer_.reset(new base::OneShotTimer<MessagePopupCollection>);
   message_center_->AddObserver(this);
+  alignment_delegate_->set_collection(this);
 }
 
 MessagePopupCollection::~MessagePopupCollection() {
   weak_factory_.InvalidateWeakPtrs();
 
-  if (screen_)
-    screen_->RemoveObserver(this);
   message_center_->RemoveObserver(this);
 
   CloseAllWidgets();
 }
 
 void MessagePopupCollection::ClickOnNotification(
     const std::string& notification_id) {
   message_center_->ClickOnNotification(notification_id);
 }
 
@@ skipping 30 matching lines @@
 
 void MessagePopupCollection::UpdateWidgets() {
   NotificationList::PopupNotifications popups =
       message_center_->GetPopupNotifications();
 
   if (popups.empty()) {
     CloseAllWidgets();
     return;
   }
 
-  bool top_down = alignment_ & POPUP_ALIGNMENT_TOP;
+  bool top_down = alignment_delegate_->IsTopDown();
   int base = GetBaseLine(toasts_.empty() ? NULL : toasts_.back());
 
   // Iterate in the reverse order to keep the oldest toasts on screen. Newer
   // items may be ignored if there are no room to place them.
   for (NotificationList::PopupNotifications::const_reverse_iterator iter =
            popups.rbegin(); iter != popups.rend(); ++iter) {
     if (FindToast((*iter)->id()))
       continue;
 
     NotificationView* view =
         NotificationView::Create(NULL,
                                  *(*iter),
                                  true); // Create top-level notification.
     view->set_context_menu_controller(context_menu_controller_.get());
     int view_height = ToastContentsView::GetToastSizeForView(view).height();
-    int height_available = top_down ? work_area_.bottom() - base : base;
+    int height_available =
+        top_down ? alignment_delegate_->GetWorkAreaBottom() - base : base;
 
     if (height_available - view_height - kToastMarginY < 0) {
       delete view;
       break;
     }
 
     ToastContentsView* toast =
         new ToastContentsView((*iter)->id(), weak_factory_.GetWeakPtr());
     // There will be no contents already since this is a new ToastContentsView.
     toast->SetContents(view, /*a11y_feedback_for_updates=*/false);
     toasts_.push_back(toast);
     view->set_controller(toast);
 
     gfx::Size preferred_size = toast->GetPreferredSize();
-    gfx::Point origin(GetToastOriginX(gfx::Rect(preferred_size)), base);
+    gfx::Point origin(
+        alignment_delegate_->GetToastOriginX(gfx::Rect(preferred_size)), base);
     // The toast slides in from the edge of the screen horizontally.
-    if (alignment_ & POPUP_ALIGNMENT_LEFT)
+    if (alignment_delegate_->IsFromLeft())
       origin.set_x(origin.x() - preferred_size.width());
     else
       origin.set_x(origin.x() + preferred_size.width());
     if (top_down)
       origin.set_y(origin.y() + view_height);
 
     toast->RevealWithAnimation(origin);
 
     // Shift the base line to be a few pixels above the last added toast or (few
     // pixels below last added toast if top-aligned).
@@ skipping 67 matching lines @@
 void MessagePopupCollection::RemoveToast(ToastContentsView* toast,
                                          bool mark_as_shown) {
   ForgetToast(toast);
 
   toast->CloseWithAnimation();
 
   if (mark_as_shown)
     message_center_->MarkSinglePopupAsShown(toast->id(), false);
 }
 
-int MessagePopupCollection::GetToastOriginX(const gfx::Rect& toast_bounds)
-    const {
-#if defined(OS_CHROMEOS)
-  // In ChromeOS, RTL UI language mirrors the whole desktop layout, so the toast
-  // widgets should be at the bottom-left instead of bottom right.
-  if (base::i18n::IsRTL())
-    return work_area_.x() + kToastMarginX;
-#endif
-  if (alignment_ & POPUP_ALIGNMENT_LEFT)
-    return work_area_.x() + kToastMarginX;
-  return work_area_.right() - kToastMarginX - toast_bounds.width();
-}
-
 void MessagePopupCollection::RepositionWidgets() {
-  bool top_down = alignment_ & POPUP_ALIGNMENT_TOP;
+  bool top_down = alignment_delegate_->IsTopDown();
   int base = GetBaseLine(NULL);  // We don't want to position relative to last
                                  // toast - we want re-position.
 
   for (Toasts::const_iterator iter = toasts_.begin(); iter != toasts_.end();) {
     Toasts::const_iterator curr = iter++;
     gfx::Rect bounds((*curr)->bounds());
-    bounds.set_x(GetToastOriginX(bounds));
-    bounds.set_y(alignment_ & POPUP_ALIGNMENT_TOP ? base
-                                                  : base - bounds.height());
+    bounds.set_x(alignment_delegate_->GetToastOriginX(bounds));
+    bounds.set_y(top_down ? base : base - bounds.height());
 
     // The notification may scrolls the boundary of the screen due to image
     // load and such notifications should disappear. Do not call
     // CloseWithAnimation, we don't want to show the closing animation, and we
     // don't want to mark such notifications as shown. See crbug.com/233424
-    if ((top_down ? work_area_.bottom() - bounds.bottom() : bounds.y()) >= 0)
+    if ((top_down ? alignment_delegate_->GetWorkAreaBottom() - bounds.bottom()
+                  : bounds.y()) >= 0)
       (*curr)->SetBoundsWithAnimation(bounds);
     else
       RemoveToast(*curr, /*mark_as_shown=*/false);
 
     // Shift the base line to be a few pixels above the last added toast or (few
     // pixels below last added toast if top-aligned).
     if (top_down)
       base += bounds.height() + kToastMarginY;
     else
       base -= bounds.height() + kToastMarginY;
   }
 }
 
 void MessagePopupCollection::RepositionWidgetsWithTarget() {
   if (toasts_.empty())
     return;
 
-  bool top_down = alignment_ & POPUP_ALIGNMENT_TOP;
+  bool top_down = alignment_delegate_->IsTopDown();
 
   // Nothing to do if there are no widgets above target if bottom-aligned or no
   // widgets below target if top-aligned.
   if (top_down ? toasts_.back()->origin().y() < target_top_edge_
                : toasts_.back()->origin().y() > target_top_edge_)
     return;
 
   Toasts::reverse_iterator iter = toasts_.rbegin();
   for (; iter != toasts_.rend(); ++iter) {
     // We only reposition widgets above target if bottom-aligned or widgets
@@ skipping 16 matching lines @@
       bounds.set_y(bounds.y() - slide_length);
     else
       bounds.set_y(bounds.y() + slide_length);
     (*iter)->SetBoundsWithAnimation(bounds);
 
     if (iter == toasts_.rbegin())
       break;
   }
 }
 
-void MessagePopupCollection::ComputePopupAlignment(gfx::Rect work_area,
-                                                   gfx::Rect screen_bounds) {
-  // If the taskbar is at the top, render notifications top down. Some platforms
-  // like Gnome can have taskbars at top and bottom. In this case it's more
-  // likely that the systray is on the top one.
-  alignment_ = work_area.y() > screen_bounds.y() ? POPUP_ALIGNMENT_TOP
-                                                 : POPUP_ALIGNMENT_BOTTOM;
-
-  // If the taskbar is on the left show the notifications on the left. Otherwise
-  // show it on right since it's very likely that the systray is on the right if
-  // the taskbar is on the top or bottom.
-  // Since on some platforms like Ubuntu Unity there's also a launcher along
-  // with a taskbar (panel), we need to check that there is really nothing at
-  // the top before concluding that the taskbar is at the left.
-  alignment_ = static_cast<PopupAlignment>(
-      alignment_ |
-      ((work_area.x() > screen_bounds.x() && work_area.y() == screen_bounds.y())
-           ? POPUP_ALIGNMENT_LEFT
-           : POPUP_ALIGNMENT_RIGHT));
-}
-
 int MessagePopupCollection::GetBaseLine(ToastContentsView* last_toast) const {
-  bool top_down = alignment_ & POPUP_ALIGNMENT_TOP;
-  int base;
-
-  if (top_down) {
-    if (!last_toast) {
-      base = work_area_.y();
-      if (!first_item_has_no_margin_)
-        base += kToastMarginY;
-      else
-        base -= kNoToastMarginBorderAndShadowOffset;
-    } else {
-      base = toasts_.back()->bounds().bottom() + kToastMarginY;
-    }
+  if (!last_toast) {
+    return alignment_delegate_->GetBaseLine();
+  } else if (alignment_delegate_->IsTopDown()) {
+    return toasts_.back()->bounds().bottom() + kToastMarginY;
   } else {
-    if (!last_toast) {
-      base = work_area_.bottom();
-      if (!first_item_has_no_margin_)
-        base -= kToastMarginY;
-      else
-        base += kNoToastMarginBorderAndShadowOffset;
-    } else {
-      base = toasts_.back()->origin().y() - kToastMarginY;
-    }
+    return toasts_.back()->origin().y() - kToastMarginY;
   }
-  return base;
 }
 
 void MessagePopupCollection::OnNotificationAdded(
     const std::string& notification_id) {
   DoUpdateIfPossible();
 }
 
 void MessagePopupCollection::OnNotificationRemoved(
     const std::string& notification_id,
     bool by_user) {
@@ skipping 104 matching lines @@
   DoUpdateIfPossible();
 }
 
 // This is the main sequencer of tasks. It does a step, then waits for
 // all started transitions to play out before doing the next step.
 // First, remove all expired toasts.
 // Then, reposition widgets (the reposition on close happens before all
 // deferred tasks are even able to run)
 // Then, see if there is vacant space for new toasts.
 void MessagePopupCollection::DoUpdateIfPossible() {
-  if (!screen_) {
-    gfx::Display display;
-    if (!parent_) {
-      // On Win+Aura, we don't have a parent since the popups currently show up
-      // on the Windows desktop, not in the Aura/Ash desktop.  This code will
-      // display the popups on the primary display.
-      screen_ = gfx::Screen::GetNativeScreen();
-      display = screen_->GetPrimaryDisplay();
-    } else {
-      screen_ = gfx::Screen::GetScreenFor(parent_);
-      display = screen_->GetDisplayNearestWindow(parent_);
-    }
-    screen_->AddObserver(this);
-
-    display_id_ = display.id();
-    // |work_area_| can be set already and it should not be overwritten here.
-    if (work_area_.IsEmpty()) {
-      work_area_ = display.work_area();
-      ComputePopupAlignment(work_area_, display.bounds());
-    }
-  }
-
   if (defer_counter_ > 0)
     return;
 
   RepositionWidgets();
 
   if (defer_counter_ > 0)
     return;
 
   // Reposition could create extra space which allows additional widgets.
   UpdateWidgets();
 
   if (defer_counter_ > 0)
     return;
 
   // Test support. Quit the test run loop when no more updates are deferred,
   // meaining th echeck for updates did not cause anything to change so no new
   // transition animations were started.
   if (run_loop_for_test_.get())
     run_loop_for_test_->Quit();
 }
 
-void MessagePopupCollection::SetDisplayInfo(const gfx::Rect& work_area,
-                                            const gfx::Rect& screen_bounds) {
-  if (work_area_ == work_area)
-    return;
-
-  work_area_ = work_area;
-  ComputePopupAlignment(work_area, screen_bounds);
-  RepositionWidgets();
-}
-
-void MessagePopupCollection::OnDisplayAdded(const gfx::Display& new_display) {
-}
-
-void MessagePopupCollection::OnDisplayRemoved(const gfx::Display& old_display) {
-  if (display_id_ == old_display.id() && !parent_) {
-    gfx::Display display = gfx::Screen::GetNativeScreen()->GetPrimaryDisplay();
-    display_id_ = display.id();
-    SetDisplayInfo(display.work_area(), display.bounds());
-  }
-}
-
 void MessagePopupCollection::OnDisplayMetricsChanged(
-    const gfx::Display& display, uint32_t metrics) {
-  if (display.id() != display_id_)
-    return;
-
-  SetDisplayInfo(display.work_area(), display.bounds());
+    const gfx::Display& display) {
+  alignment_delegate_->RecomputeAlignment(display);
 }
 
 views::Widget* MessagePopupCollection::GetWidgetForTest(const std::string& id)
     const {
   for (Toasts::const_iterator iter = toasts_.begin(); iter != toasts_.end();
        ++iter) {
     if ((*iter)->id() == id)
       return (*iter)->GetWidget();
   }
   return NULL;
@@ skipping 17 matching lines @@
       views::Widget* widget = (*iter)->GetWidget();
       if (widget)
         return widget->GetWindowBoundsInScreen();
       break;
     }
   }
   return gfx::Rect();
 }
 
 }  // namespace message_center