Change Ash web notification behavior

ash/system/tray/system_tray.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/system/tray/system_tray.h"
 
 #include "ash/shell.h"
 #include "ash/shell/panel_window.h"
 #include "ash/shell_window_ids.h"
 #include "ash/system/audio/tray_volume.h"
 #include "ash/system/bluetooth/tray_bluetooth.h"
 #include "ash/system/brightness/tray_brightness.h"
 #include "ash/system/date/tray_date.h"
 #include "ash/system/drive/tray_drive.h"
 #include "ash/system/ime/tray_ime.h"
 #include "ash/system/locale/tray_locale.h"
 #include "ash/system/network/tray_network.h"
 #include "ash/system/network/tray_sms.h"
 #include "ash/system/power/power_status_observer.h"
 #include "ash/system/power/power_supply_status.h"
 #include "ash/system/power/tray_power.h"
 #include "ash/system/settings/tray_settings.h"
+#include "ash/system/status_area_widget.h"
 #include "ash/system/tray/system_tray_bubble.h"
 #include "ash/system/tray/system_tray_delegate.h"
 #include "ash/system/tray/system_tray_item.h"
 #include "ash/system/tray/tray_constants.h"
 #include "ash/system/tray_accessibility.h"
 #include "ash/system/tray_caps_lock.h"
 #include "ash/system/tray_update.h"
 #include "ash/system/user/login_status.h"
 #include "ash/system/user/tray_user.h"
 #include "ash/wm/shelf_layout_manager.h"
 #include "base/logging.h"
 #include "base/timer.h"
 #include "base/utf_string_conversions.h"
 #include "grit/ash_strings.h"
 #include "ui/aura/root_window.h"
 #include "ui/base/accessibility/accessible_view_state.h"
 #include "ui/base/events.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/views/border.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/views/layout/fill_layout.h"
 #include "ui/views/view.h"
 
-namespace {
-
-// Adjust the size of SystemTrayContainer with additional padding.
-const int kTrayContainerVerticalPaddingBottomAlignment  = 1;
-const int kTrayContainerHorizontalPaddingBottomAlignment  = 1;
-const int kTrayContainerVerticalPaddingVerticalAlignment  = 1;
-const int kTrayContainerHorizontalPaddingVerticalAlignment = 1;
-
-}  // namespace
-
 namespace ash {
 
 namespace internal {
 
-// Container for all the items in the tray. The container auto-resizes the
-// widget when necessary.
-class SystemTrayContainer : public views::View {
- public:
-  SystemTrayContainer() {}
-  virtual ~SystemTrayContainer() {}
-
-  void UpdateLayout(ShelfAlignment alignment) {
-    // Adjust the size of status tray dark background by adding additional
-    // empty border.
-    if (alignment == SHELF_ALIGNMENT_BOTTOM) {
-      set_border(views::Border::CreateEmptyBorder(
-          kTrayContainerVerticalPaddingBottomAlignment,
-          kTrayContainerHorizontalPaddingBottomAlignment,
-          kTrayContainerVerticalPaddingBottomAlignment,
-          kTrayContainerHorizontalPaddingBottomAlignment));
-      views::View::SetLayoutManager(new views::BoxLayout(
-          views::BoxLayout::kHorizontal, 0, 0, 0));
-    } else {
-      set_border(views::Border::CreateEmptyBorder(
-          kTrayContainerVerticalPaddingVerticalAlignment,
-          kTrayContainerHorizontalPaddingVerticalAlignment,
-          kTrayContainerVerticalPaddingVerticalAlignment,
-          kTrayContainerHorizontalPaddingVerticalAlignment));
-      views::View::SetLayoutManager(new views::BoxLayout(
-          views::BoxLayout::kVertical, 0, 0, 0));
-    }
-    PreferredSizeChanged();
-  }
-
- private:
-  // Overridden from views::View.
-  virtual void ChildPreferredSizeChanged(views::View* child) OVERRIDE {
-    PreferredSizeChanged();
-  }
-
-  virtual void ChildVisibilityChanged(View* child) OVERRIDE {
-    PreferredSizeChanged();
-  }
-
-  virtual void ViewHierarchyChanged(bool is_add,
-                                    View* parent,
-                                    View* child) OVERRIDE {
-    if (parent == this)
-      PreferredSizeChanged();
-  }
-
-  DISALLOW_COPY_AND_ASSIGN(SystemTrayContainer);
-};
-
 // Observe the tray layer animation and update the anchor when it changes.
 // TODO(stevenjb): Observe or mirror the actual animation, not just the start
 // and end points.
 class SystemTrayLayerAnimationObserver : public ui::LayerAnimationObserver {
  public:
   explicit SystemTrayLayerAnimationObserver(SystemTray* host) : host_(host) {}
 
   virtual void OnLayerAnimationEnded(ui::LayerAnimationSequence* sequence) {
     host_->UpdateNotificationAnchor();
   }
@@ skipping 13 matching lines @@
 };
 
 }  // namespace internal
 
 // SystemTray
 
 using internal::SystemTrayBubble;
 using internal::SystemTrayLayerAnimationObserver;
 using internal::TrayBubbleView;
 
-SystemTray::SystemTray()
-    : items_(),
+SystemTray::SystemTray(internal::StatusAreaWidget* status_area_widget)
+    : internal::TrayBackgroundView(status_area_widget),
+      items_(),
       accessibility_observer_(NULL),
       audio_observer_(NULL),
       bluetooth_observer_(NULL),
       brightness_observer_(NULL),
       caps_lock_observer_(NULL),
       clock_observer_(NULL),
       drive_observer_(NULL),
       ime_observer_(NULL),
       locale_observer_(NULL),
       network_observer_(NULL),
       update_observer_(NULL),
       user_observer_(NULL),
       should_show_launcher_(false),
       default_bubble_height_(0),
       hide_notifications_(false) {
-  tray_container_ = new internal::SystemTrayContainer;
-  tray_container_->UpdateLayout(shelf_alignment());
-  SetContents(tray_container_);
-  SetBorder();
 }
 
 SystemTray::~SystemTray() {
   bubble_.reset();
   for (std::vector<SystemTrayItem*>::iterator it = items_.begin();
        it != items_.end();
        ++it) {
     (*it)->DestroyTrayView();
   }
 }
@@ skipping 59 matching lines @@
 
 void SystemTray::AddTrayItem(SystemTrayItem* item) {
   items_.push_back(item);
 
   SystemTrayDelegate* delegate = Shell::GetInstance()->tray_delegate();
   views::View* tray_item = item->CreateTrayView(delegate->GetUserLoginStatus());
   item->UpdateAfterShelfAlignmentChange(
       ash::Shell::GetInstance()->system_tray()->shelf_alignment());
 
   if (tray_item) {
-    tray_container_->AddChildViewAt(tray_item, 0);
+    tray_container()->AddChildViewAt(tray_item, 0);
     PreferredSizeChanged();
     tray_item_map_[item] = tray_item;
   }
 }
 
 void SystemTray::RemoveTrayItem(SystemTrayItem* item) {
   NOTIMPLEMENTED();
 }
 
 void SystemTray::ShowDefaultView(BubbleCreationType creation_type) {
@@ skipping 63 matching lines @@
     (*it)->UpdateAfterShelfAlignmentChange(alignment);
   }
 }
 
 void SystemTray::SetHideNotifications(bool hide_notifications) {
   if (notification_bubble_.get())
     notification_bubble_->SetVisible(!hide_notifications);
   hide_notifications_ = hide_notifications;
 }
 
-bool SystemTray::IsBubbleVisible() const {
-  return bubble_.get() && bubble_->IsVisible();
+bool SystemTray::IsAnyBubbleVisible() const {
+  if (bubble_.get() && bubble_->IsVisible())
+    return true;
+  if (notification_bubble_.get() && notification_bubble_->IsVisible())
+    return true;
+  return false;
 }
 
 bool SystemTray::CloseBubbleForTest() const {
   if (!bubble_.get())
     return false;
   bubble_->Close();
   return true;
 }
 
 // Private methods.
@@ skipping 62 matching lines @@
   // Destroy the notification bubble here so that it doesn't get rebuilt
   // while we add items to the main bubble_ (e.g. in HideNotificationView).
   notification_bubble_.reset();
 
   if (bubble_.get() && creation_type == BUBBLE_USE_EXISTING) {
     bubble_->UpdateView(items, bubble_type);
   } else {
     bubble_.reset(new SystemTrayBubble(this, items, bubble_type));
     ash::SystemTrayDelegate* delegate =
         ash::Shell::GetInstance()->tray_delegate();
-    views::View* anchor = tray_container_;
+    views::View* anchor = tray_container();
     TrayBubbleView::InitParams init_params(TrayBubbleView::ANCHOR_TYPE_TRAY,
                                            shelf_alignment());
     init_params.can_activate = can_activate;
     if (detailed) {
       // This is the case where a volume control or brightness control bubble
       // is created.
       init_params.max_height = default_bubble_height_;
       init_params.arrow_color = kBackgroundColor;
     }
     init_params.arrow_offset = arrow_offset;
     bubble_->InitView(anchor, init_params, delegate->GetUserLoginStatus());
   }
   // Save height of default view for creating detailed views directly.
   if (!detailed)
     default_bubble_height_ = bubble_->bubble_view()->height();
 
   if (detailed && items.size() > 0)
     detailed_item_ = items[0];
   else
     detailed_item_ = NULL;
 
   // If we have focus the shelf should be visible and we need to continue
   // showing the shelf when the popup is shown.
   if (GetWidget()->IsActive())
     should_show_launcher_ = true;
 
   UpdateNotificationBubble();  // State changed, re-create notifications.
+  status_area_widget()->HideNonSystemNotifications();
 }
 
 void SystemTray::UpdateNotificationBubble() {
   // Only show the notification buble if we have notifications and we are not
   // showing the default bubble.
   if (notification_items_.empty() ||
       (bubble_.get() &&
        bubble_->bubble_type() == SystemTrayBubble::BUBBLE_TYPE_DEFAULT)) {
     notification_bubble_.reset();
     return;
@@ skipping 14 matching lines @@
     // Show all notifications.
     notification_bubble_.reset(new SystemTrayBubble(
         this, notification_items_, SystemTrayBubble::BUBBLE_TYPE_NOTIFICATION));
   }
   views::View* anchor;
   TrayBubbleView::AnchorType anchor_type;
   if (bubble_.get()) {
     anchor = bubble_->bubble_view();
     anchor_type = TrayBubbleView::ANCHOR_TYPE_BUBBLE;
   } else {
-    anchor = tray_container_;
+    anchor = tray_container();
     anchor_type = TrayBubbleView::ANCHOR_TYPE_TRAY;
   }
   TrayBubbleView::InitParams init_params(anchor_type, shelf_alignment());
   init_params.arrow_offset = GetTrayXOffset(notification_items_[0]);
   init_params.arrow_color = kBackgroundColor;
   user::LoginStatus login_status =
       Shell::GetInstance()->tray_delegate()->GetUserLoginStatus();
   notification_bubble_->InitView(anchor, init_params, login_status);
   if (hide_notifications_)
     notification_bubble_->SetVisible(false);
+  else
+    status_area_widget()->HideNonSystemNotifications();
 }
 
 void SystemTray::UpdateNotificationAnchor() {
   if (!notification_bubble_.get())
     return;
   notification_bubble_->bubble_view()->UpdateBubble();
   // Ensure that the notification buble is above the launcher/status area.
   notification_bubble_->bubble_view()->GetWidget()->StackAtTop();
 }
 
-void SystemTray::SetBorder() {
-  // Change the border padding for different shelf alignment.
-  if (shelf_alignment() == SHELF_ALIGNMENT_BOTTOM) {
-    set_border(views::Border::CreateEmptyBorder(0, 0,
-        kPaddingFromBottomOfScreenBottomAlignment,
-        kPaddingFromRightEdgeOfScreenBottomAlignment));
-  } else if (shelf_alignment() == SHELF_ALIGNMENT_LEFT) {
-    set_border(views::Border::CreateEmptyBorder(0,
-        kPaddingFromOuterEdgeOfLauncherVerticalAlignment,
-        kPaddingFromBottomOfScreenVerticalAlignment,
-        kPaddingFromInnerEdgeOfLauncherVerticalAlignment));
-  } else {
-    set_border(views::Border::CreateEmptyBorder(0,
-        kPaddingFromInnerEdgeOfLauncherVerticalAlignment,
-        kPaddingFromBottomOfScreenVerticalAlignment,
-        kPaddingFromOuterEdgeOfLauncherVerticalAlignment));
-  }
-}
-
 void SystemTray::SetShelfAlignment(ShelfAlignment alignment) {
   if (alignment == shelf_alignment())
     return;
   internal::TrayBackgroundView::SetShelfAlignment(alignment);
   UpdateAfterShelfAlignmentChange(alignment);
-  SetBorder();
-  tray_container_->UpdateLayout(alignment);
   // Destroy any existing bubble so that it is rebuilt correctly.
   bubble_.reset();
   // Rebuild any notification bubble.
   if (notification_bubble_.get()) {
     notification_bubble_.reset();
     UpdateNotificationBubble();
   }
 }
 
 bool SystemTray::PerformAction(const views::Event& event) {
@@ skipping 44 matching lines @@
 
 void SystemTray::OnPaintFocusBorder(gfx::Canvas* canvas) {
   // The tray itself expands to the right and bottom edge of the screen to make
   // sure clicking on the edges brings up the popup. However, the focus border
   // should be only around the container.
   if (GetWidget() && GetWidget()->IsActive())
     DrawBorder(canvas, GetContentsBounds());
 }
 
 }  // namespace ash