Fix the problem that notifications and panels overlap.

chrome/browser/notifications/balloon_collection_impl.cc

 // Copyright (c) 2011 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/notifications/balloon_collection_impl.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "chrome/browser/notifications/balloon.h"
 #include "chrome/browser/notifications/balloon_host.h"
 #include "chrome/browser/notifications/notification.h"
+#include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/panels/panel_manager.h"
+#include "chrome/browser/ui/panels/panel.h"
 #include "chrome/browser/ui/window_sizer.h"
+#include "chrome/common/chrome_notification_types.h"
+#include "content/public/browser/notification_registrar.h"
+#include "content/public/browser/notification_service.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
 
 namespace {
 
 // Portion of the screen allotted for notifications. When notification balloons
 // extend over this, no new notifications are shown until some are closed.
 const double kPercentBalloonFillFactor = 0.7;
 
 // Allow at least this number of balloons on the screen.
 const int kMinAllowedBalloonCount = 2;
 
 // Delay from the mouse leaving the balloon collection before
 // there is a relayout, in milliseconds.
 const int kRepositionDelay = 300;
 
 }  // namespace
 
 BalloonCollectionImpl::BalloonCollectionImpl()
 #if USE_OFFSETS
     : ALLOW_THIS_IN_INITIALIZER_LIST(reposition_factory_(this)),
       added_as_message_loop_observer_(false)
 #endif
 {
+  registrar_.Add(this, chrome::NOTIFICATION_BROWSER_WINDOW_READY,
+                 content::NotificationService::AllSources());
+  registrar_.Add(this, chrome::NOTIFICATION_BROWSER_CLOSED,
+                 content::NotificationService::AllSources());
+  registrar_.Add(this, chrome::NOTIFICATION_PANEL_CHANGED_BOUNDS,
+                 content::NotificationService::AllSources());
 
   SetPositionPreference(BalloonCollection::DEFAULT_POSITION);
 }
 
 BalloonCollectionImpl::~BalloonCollectionImpl() {
 }
 
 void BalloonCollectionImpl::Add(const Notification& notification,
                                 Profile* profile) {
   Balloon* new_balloon = MakeBalloon(notification, profile);
@@ skipping 98 matching lines @@
 
   // This is used only for testing.
   if (!on_collection_changed_callback_.is_null())
     on_collection_changed_callback_.Run();
 }
 
 const BalloonCollection::Balloons& BalloonCollectionImpl::GetActiveBalloons() {
   return base_.balloons();
 }
 
+void BalloonCollectionImpl::Observe(
+    int type,
+    const content::NotificationSource& source,
+    const content::NotificationDetails& details) {
+  switch (type) {
+    case chrome::NOTIFICATION_BROWSER_WINDOW_READY:
+    case chrome::NOTIFICATION_BROWSER_CLOSED: {
+      Browser* browser = content::Source<Browser>(source).ptr();
+      if (browser->is_type_panel())
+        PositionBalloons(true);
+      break;
+    }
+    case chrome::NOTIFICATION_PANEL_CHANGED_BOUNDS:
+      PositionBalloons(true);
+      break;
+    default:
+      NOTREACHED();
+      break;
+  }
+}
+
 void BalloonCollectionImpl::PositionBalloonsInternal(bool reposition) {
   const Balloons& balloons = base_.balloons();
 
   layout_.RefreshSystemMetrics();
   gfx::Point origin = layout_.GetLayoutOrigin();
   for (Balloons::const_iterator it = balloons.begin();
        it != balloons.end();
        ++it) {
     gfx::Point upper_left = layout_.NextPosition((*it)->GetViewSize(), &origin);
     (*it)->SetPosition(upper_left, reposition);
@@ skipping 58 matching lines @@
                      reposition_factory_.GetWeakPtr()),
           kRepositionDelay);
     }
   } else {
     // Mouse moved back into the region.  Cancel the reposition.
     reposition_factory_.InvalidateWeakPtrs();
   }
 }
 #endif
 
-BalloonCollectionImpl::Layout::Layout() : placement_(INVALID) {
+BalloonCollectionImpl::Layout::Layout()
+    : placement_(INVALID),
+      panel_height_base_(0) {
   RefreshSystemMetrics();
 }
 
 void BalloonCollectionImpl::Layout::GetMaxLinearSize(int* max_balloon_size,
                                                      int* total_size) const {
   DCHECK(max_balloon_size && total_size);
 
   // All placement schemes are vertical, so we only care about height.
   *total_size = work_area_.height();
   *max_balloon_size = max_balloon_height();
 }
 
 gfx::Point BalloonCollectionImpl::Layout::GetLayoutOrigin() const {
   int x = 0;
   int y = 0;
   switch (placement_) {
     case VERTICALLY_FROM_TOP_LEFT:
       x = work_area_.x() + HorizontalEdgeMargin();
       y = work_area_.y() + VerticalEdgeMargin();
       break;
     case VERTICALLY_FROM_TOP_RIGHT:
       x = work_area_.right() - HorizontalEdgeMargin();
       y = work_area_.y() + VerticalEdgeMargin();
       break;
     case VERTICALLY_FROM_BOTTOM_LEFT:
       x = work_area_.x() + HorizontalEdgeMargin();
       y = work_area_.bottom() - VerticalEdgeMargin();
       break;
-    case VERTICALLY_FROM_BOTTOM_RIGHT:
+    case VERTICALLY_FROM_BOTTOM_RIGHT: {
       x = work_area_.right() - HorizontalEdgeMargin();
-      y = work_area_.bottom() - VerticalEdgeMargin();
+      // For this placement, balloon needs to stay on top of right-most panels
+      // to avoid overlapping.
+      y = work_area_.bottom() - VerticalEdgeMargin() - panel_height_base_;
       break;
+    }
     default:
       NOTREACHED();
       break;
   }
   return gfx::Point(x, y);
 }
 
 gfx::Point BalloonCollectionImpl::Layout::NextPosition(
     const gfx::Size& balloon_size,
     gfx::Point* position_iterator) const {
@@ skipping 79 matching lines @@
 gfx::Size BalloonCollectionImpl::Layout::ConstrainToSizeLimits(
     const gfx::Size& size) {
   // restrict to the min & max sizes
   return gfx::Size(
       std::max(min_balloon_width(),
                std::min(max_balloon_width(), size.width())),
       std::max(min_balloon_height(),
                std::min(max_balloon_height(), size.height())));
 }
 
+int BalloonCollectionImpl::Layout::GetPanelHeightBase() const {

[Dmitry Titov, 2011/11/09 03:09:57]

If we add a method on PanelManager to pull this height from there, then we don't
need to expose 'panels' and 'horizontal_spacing' from PanelManager. It seems to
be a bit cleaner then.

[jianli, 2011/11/09 19:04:40]

Indeed we don't need to expose 'horizontal_spacing'. I think  the logic here to
compute the offset is specific to notifications itself. I rather keep it here
since moving to PanelManager to have this specific method for notification
sounds also not clean enough. Now we only need to expose 'panels' getter.

+  // The height base is computed based on the maximum height of the right-most
+  // panels that could overlap with the balloon.
+  int height_base = 0;
+  const PanelManager::Panels& panels = PanelManager::GetInstance()->panels();
+  for (PanelManager::Panels::const_iterator iter = panels.begin();
+       iter != panels.end(); ++iter) {
+    if ((*iter)->GetBounds().right() + PanelManager::horizontal_spacing() <=
+        work_area_.right() - max_balloon_width())
+      break;
+    int current_height = (*iter)->GetBounds().height();
+    if (current_height > height_base)
+      height_base = current_height;
+  }
+  return height_base;
+}
+
 bool BalloonCollectionImpl::Layout::RefreshSystemMetrics() {
   bool changed = false;
 
 #if defined(OS_MACOSX)
   gfx::Rect new_work_area = GetMacWorkArea();
 #else
   scoped_ptr<WindowSizer::MonitorInfoProvider> info_provider(
       WindowSizer::CreateDefaultMonitorInfoProvider());
   gfx::Rect new_work_area = info_provider->GetPrimaryMonitorWorkArea();
 #endif
   if (!work_area_.Equals(new_work_area)) {
     work_area_.SetRect(new_work_area.x(), new_work_area.y(),
                        new_work_area.width(), new_work_area.height());
     changed = true;
   }
 
+  panel_height_base_ = GetPanelHeightBase();
+
   return changed;
 }