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,

[jennb, 2011/11/10 19:17:13]

Instead of these browser notifications, perhaps better to have a PANEL
notifications sent by the panel manager after removing a panel? Then you don't
have to track if a browser is closing or not. Also, window_ready is sent before
panel manager has added the new panel to its list.

[jianli, 2011/11/11 00:38:30]

Done.

+                 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) {
+  Browser* closed_browser = NULL;
+  switch (type) {
+    case chrome::NOTIFICATION_BROWSER_WINDOW_READY: {
+      Browser* browser = content::Source<Browser>(source).ptr();
+      if (!browser->is_type_panel())
+        return;
+      break;
+    }
+    case chrome::NOTIFICATION_BROWSER_CLOSED: {
+      Browser* browser = content::Source<Browser>(source).ptr();
+      if (!browser->is_type_panel())
+        return;
+      closed_browser = browser;

[Dmitry Titov, 2011/11/10 18:35:45]

Lets add a notification when panel is removed from the PanelManager and then use
that one here. This will allow to remove the closed_browser parameter.

[jianli, 2011/11/11 00:38:30]

Done.

+      break;
+    }
+    case chrome::NOTIFICATION_PANEL_CHANGED_BOUNDS:

[jennb, 2011/11/10 19:17:13]

Should you check the panel bounds here and only do work if the panel bounds are
within the balloon area?

[jianli, 2011/11/11 00:38:30]

Done.

+      break;
+    default:
+      NOTREACHED();
+      return;
+  }
+
+  if (layout_.ComputeOffsetsToMoveAbovePanels(closed_browser))
+    PositionBalloons(true);
+}
+
 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),
+      bottom_left_offset_to_move_above_panels_(0),
+      bottom_right_offset_to_move_above_panels_(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:
-      x = work_area_.right() - HorizontalEdgeMargin();
-      y = work_area_.bottom() - VerticalEdgeMargin();
-      break;
-    default:
-      NOTREACHED();
-      break;
-  }
-  return gfx::Point(x, y);
-}
-
 gfx::Point BalloonCollectionImpl::Layout::NextPosition(
     const gfx::Size& balloon_size,
     gfx::Point* position_iterator) const {
   DCHECK(position_iterator);
 
   int x = 0;
   int y = 0;
   switch (placement_) {
     case VERTICALLY_FROM_TOP_LEFT:
       x = position_iterator->x();
@@ skipping 20 matching lines @@
       y = position_iterator->y();
       break;
     default:
       NOTREACHED();
       break;
   }
   return gfx::Point(x, y);
 }
 
 gfx::Point BalloonCollectionImpl::Layout::OffScreenLocation() const {
-  int x = 0;
-  int y = 0;
+  gfx::Point location = GetLayoutOrigin();
   switch (placement_) {
     case VERTICALLY_FROM_TOP_LEFT:
-      x = work_area_.x() + HorizontalEdgeMargin();
-      y = work_area_.y() + kBalloonMaxHeight + VerticalEdgeMargin();
+    case VERTICALLY_FROM_BOTTOM_LEFT:
+      location.Offset(0, kBalloonMaxHeight);
       break;
     case VERTICALLY_FROM_TOP_RIGHT:
-      x = work_area_.right() - kBalloonMaxWidth - HorizontalEdgeMargin();
-      y = work_area_.y() + kBalloonMaxHeight + VerticalEdgeMargin();
-      break;
-    case VERTICALLY_FROM_BOTTOM_LEFT:
-      x = work_area_.x() + HorizontalEdgeMargin();
-      y = work_area_.bottom() + kBalloonMaxHeight + VerticalEdgeMargin();
-      break;
     case VERTICALLY_FROM_BOTTOM_RIGHT:
-      x = work_area_.right() - kBalloonMaxWidth - HorizontalEdgeMargin();
-      y = work_area_.bottom() + kBalloonMaxHeight + VerticalEdgeMargin();
+      location.Offset(-kBalloonMaxWidth, kBalloonMaxHeight);
       break;
     default:
       NOTREACHED();
       break;
   }
-  return gfx::Point(x, y);
+  return location;
 }
 
 bool BalloonCollectionImpl::Layout::RequiresOffsets() const {
   // Layout schemes that grow up from the bottom require offsets;
   // schemes that grow down do not require offsets.
   bool offsets = (placement_ == VERTICALLY_FROM_BOTTOM_LEFT ||
                   placement_ == VERTICALLY_FROM_BOTTOM_RIGHT);
 
 #if defined(OS_MACOSX)
   // These schemes are in screen-coordinates, and top and bottom
   // are inverted on Mac.
   offsets = !offsets;
 #endif
 
   return offsets;
 }
 
 // static
 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())));
 }
 
+bool BalloonCollectionImpl::Layout::ComputeOffsetsToMoveAbovePanels(
+    Browser* closed_browser) {
+  const PanelManager::Panels& panels = PanelManager::GetInstance()->panels();
+
+  // For balloons that are aligned vertically from bottom-right corner, the
+  // offset is the maximum height of the right-most panels that could overlap
+  // with the balloons.
+  int bottom_right_offset_to_move_above_panels = 0;
+  for (PanelManager::Panels::const_iterator iter = panels.begin();
+       iter != panels.end(); ++iter) {
+    // No need to check panels beyond the area occupied by the balloons.
+    if ((*iter)->GetBounds().right() <=
+        work_area_.right() - max_balloon_width())
+      break;
+
+    // Skip the panel that is currently being closed. We might not remove it
+    // from the panel manager yet.
+    if ((*iter)->browser() == closed_browser)
+      continue;
+
+    int current_height = (*iter)->GetBounds().height();
+    if (current_height > bottom_right_offset_to_move_above_panels)
+      bottom_right_offset_to_move_above_panels = current_height;
+  }
+
+  // For balloons that are aligned vertically from bottom-left corner, the
+  // offset is the maximum height of the left-most panels that could overlap
+  // with the balloons.
+  int bottom_left_offset_to_move_above_panels = 0;
+  for (PanelManager::Panels::const_reverse_iterator iter = panels.rbegin();
+       iter != panels.rend(); ++iter) {
+    // No need to check panels beyond the area occupied by the balloons.
+    if ((*iter)->GetBounds().x() > work_area_.x() + max_balloon_width())
+      break;
+
+    // Skip the panel that is currently being closed. We might not remove it
+    // from the panel manager yet.
+    if ((*iter)->browser() == closed_browser)
+      continue;
+
+    int current_height = (*iter)->GetBounds().height();
+    if (current_height > bottom_left_offset_to_move_above_panels)
+      bottom_left_offset_to_move_above_panels = current_height;
+  }
+
+  // If no change is detected, return false to indicate that we do not need to
+  // reposition balloons.
+  if (bottom_right_offset_to_move_above_panels_ ==
+      bottom_right_offset_to_move_above_panels &&
+      bottom_left_offset_to_move_above_panels_ ==
+      bottom_left_offset_to_move_above_panels) {
+    return false;
+  }
+
+  bottom_right_offset_to_move_above_panels_ =
+      bottom_right_offset_to_move_above_panels;
+  bottom_left_offset_to_move_above_panels_ =
+      bottom_left_offset_to_move_above_panels;
+  return true;
+}
+
 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;
   }
 
   return changed;
 }