Re-factor Ash Message Center code part 3/4

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_bubble_wrapper.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_display.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/events/event_constants.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"
 
+using message_center::TrayBubbleView;
+
 namespace ash {
 
+namespace internal {
+
+// Class to initialize and manage the SystemTrayBubble and TrayBubbleWrapper
+// instances for a bubble.
+
+class SystemBubbleWrapper {
+ public:
+  // Takes ownership of |bubble| and creates |bubble_wrapper_|.
+  SystemBubbleWrapper(TrayBackgroundView* tray,
+                      internal::SystemTrayBubble* bubble,
+                      views::View* anchor,
+                      TrayBubbleView::InitParams* init_params) {
+    bubble_.reset(bubble);

[miket_OOO, 2012/10/16 01:05:42]

Could this be an initializer?

[stevenjb, 2012/10/16 19:16:06]

Done.

+    user::LoginStatus login_status =
+        Shell::GetInstance()->tray_delegate()->GetUserLoginStatus();
+    bubble->InitView(anchor, login_status, init_params);
+    bubble_wrapper_.reset(
+        new internal::TrayBubbleWrapper(tray, bubble->bubble_view()));
+  }
+
+  // Convenience accessors:
+  SystemTrayBubble* bubble() const { return bubble_.get(); }
+  SystemTrayBubble::BubbleType bubble_type() const {
+    return bubble_->bubble_type();
+  }
+  TrayBubbleView* bubble_view() const { return bubble_->bubble_view(); }
+
+ private:
+  scoped_ptr<internal::SystemTrayBubble> bubble_;
+  scoped_ptr<internal::TrayBubbleWrapper> bubble_wrapper_;
+};
+
+}  // namespace internal
+
 // SystemTray
 
 using internal::SystemTrayBubble;
 
 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),
       default_bubble_height_(0),
       hide_notifications_(false) {
   SetContentsBackground();
 }
 
 SystemTray::~SystemTray() {
-  bubble_.reset();
+  system_bubble_.reset();
+  notification_bubble_.reset();

[miket_OOO, 2012/10/16 01:05:42]

I don't see why these are necessary. Does the DestroyTrayView() below somehow
depend on these guys giving up the resources before it runs? If so, a comment to
the effect that the ordering is necessary might help someone who's blindly
optimizing away scoped_ptr resets in destructors.

[stevenjb, 2012/10/16 19:16:06]

The order here doesn't really matter, they just need to be destroyed before
~View() since the bubbles otherwise may have back pointers that will become
invalid. Added a comment.

   for (std::vector<SystemTrayItem*>::iterator it = items_.begin();
        it != items_.end();
        ++it) {
     (*it)->DestroyTrayView();
   }
 }
 
 void SystemTray::CreateItems() {
   internal::TrayVolume* tray_volume = new internal::TrayVolume();
   internal::TrayBluetooth* tray_bluetooth = new internal::TrayBluetooth();
@@ skipping 72 matching lines @@
                             TrayBubbleView::InitParams::kArrowDefaultOffset);
 }
 
 void SystemTray::ShowDetailedView(SystemTrayItem* item,
                                   int close_delay,
                                   bool activate,
                                   BubbleCreationType creation_type) {
   std::vector<SystemTrayItem*> items;
   items.push_back(item);
   ShowItems(items, true, activate, creation_type, GetTrayXOffset(item));
-  bubble_->StartAutoCloseTimer(close_delay);
+  system_bubble_->bubble()->StartAutoCloseTimer(close_delay);
 }
 
 void SystemTray::SetDetailedViewCloseDelay(int close_delay) {
-  if (bubble_.get() &&
-      bubble_->bubble_type() == SystemTrayBubble::BUBBLE_TYPE_DETAILED)
-    bubble_->StartAutoCloseTimer(close_delay);
+  if (HasSystemBubbleType(SystemTrayBubble::BUBBLE_TYPE_DETAILED))
+    system_bubble_->bubble()->StartAutoCloseTimer(close_delay);
 }
 
 void SystemTray::HideDetailedView(SystemTrayItem* item) {
   if (item != detailed_item_)
     return;
-  DestroyBubble();
+  DestroySystemBubble();
   UpdateNotificationBubble();
 }
 
 void SystemTray::ShowNotificationView(SystemTrayItem* item) {
   if (std::find(notification_items_.begin(), notification_items_.end(), item)
       != notification_items_.end())
     return;
   notification_items_.push_back(item);
   UpdateNotificationBubble();
 }
 
 void SystemTray::HideNotificationView(SystemTrayItem* item) {
   std::vector<SystemTrayItem*>::iterator found_iter =
       std::find(notification_items_.begin(), notification_items_.end(), item);
   if (found_iter == notification_items_.end())
     return;
   notification_items_.erase(found_iter);
   // Only update the notification bubble if visible (i.e. don't create one).
   if (notification_bubble_.get())
     UpdateNotificationBubble();
 }
 
 void SystemTray::UpdateAfterLoginStatusChange(user::LoginStatus login_status) {
-  DestroyBubble();
+  DestroySystemBubble();
 
   for (std::vector<SystemTrayItem*>::iterator it = items_.begin();
       it != items_.end();
       ++it) {
     (*it)->UpdateAfterLoginStatusChange(login_status);
   }
 
   SetVisible(true);
   PreferredSizeChanged();
 }
 
 void SystemTray::UpdateAfterShelfAlignmentChange(ShelfAlignment alignment) {
   for (std::vector<SystemTrayItem*>::iterator it = items_.begin();
       it != items_.end();
       ++it) {
     (*it)->UpdateAfterShelfAlignmentChange(alignment);
   }
 }
 
 void SystemTray::SetHideNotifications(bool hide_notifications) {
   if (notification_bubble_.get())
-    notification_bubble_->SetVisible(!hide_notifications);
+    notification_bubble_->bubble()->SetVisible(!hide_notifications);
   hide_notifications_ = hide_notifications;
 }
 
 bool SystemTray::HasSystemBubble() const {
-  return bubble_.get() != NULL;
+  return system_bubble_.get() != NULL;
+}
+
+internal::SystemTrayBubble* SystemTray::GetSystemBubble() {
+  if (!system_bubble_.get())
+    return NULL;
+  return system_bubble_->bubble();
 }
 
 bool SystemTray::IsAnyBubbleVisible() const {
-  if (bubble_.get() && bubble_->IsVisible())
-    return true;
-  if (notification_bubble_.get() && notification_bubble_->IsVisible())
-    return true;
-  return false;
+  return ((system_bubble_.get() &&
+           system_bubble_->bubble()->IsVisible()) ||
+          (notification_bubble_.get() &&
+           notification_bubble_->bubble()->IsVisible()));
 }
 
 bool SystemTray::IsMouseInNotificationBubble() const {
   if (!notification_bubble_.get())
     return false;
   return notification_bubble_->bubble_view()->GetBoundsInScreen().Contains(
       Shell::GetScreen()->GetCursorScreenPoint());
 }
 
 bool SystemTray::CloseBubbleForTest() const {
-  if (!bubble_.get())
+  if (!system_bubble_.get())
     return false;
-  bubble_->Close();
+  system_bubble_->bubble()->Close();
   return true;
 }
 
 // Private methods.
 
-void SystemTray::DestroyBubble() {
-  bubble_.reset();
+bool SystemTray::HasSystemBubbleType(SystemTrayBubble::BubbleType type) {
+  DCHECK(type != SystemTrayBubble::BUBBLE_TYPE_NOTIFICATION);
+  return system_bubble_.get() && system_bubble_->bubble_type() == type;
+}
+
+void SystemTray::DestroySystemBubble() {
+  system_bubble_.reset();
   detailed_item_ = NULL;
 }
 
 void SystemTray::DestroyNotificationBubble() {
   notification_bubble_.reset();
   status_area_widget()->SetHideWebNotifications(false);
 }
 
 int SystemTray::GetTrayXOffset(SystemTrayItem* item) const {
   // Don't attempt to align the arrow if the shelf is on the left or right.
@@ skipping 29 matching lines @@
                            int arrow_offset) {
   // Destroy any existing bubble and create a new one.
   SystemTrayBubble::BubbleType bubble_type = detailed ?
       SystemTrayBubble::BUBBLE_TYPE_DETAILED :
       SystemTrayBubble::BUBBLE_TYPE_DEFAULT;
 
   // 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);
+  if (system_bubble_.get() && creation_type == BUBBLE_USE_EXISTING) {
+    system_bubble_->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();
     TrayBubbleView::InitParams init_params(TrayBubbleView::ANCHOR_TYPE_TRAY,
                                            GetAnchorAlignment(),
                                            kTrayPopupWidth);
     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.top_color = kBackgroundColor;
       init_params.arrow_color = kBackgroundColor;
     } else {
       init_params.top_color = kBackgroundColor;
       init_params.arrow_color = kHeaderBackgroundColorDark;
     }
     init_params.arrow_offset = arrow_offset;
-    bubble_->InitView(anchor, delegate->GetUserLoginStatus(), &init_params);
+    SystemTrayBubble* bubble = new SystemTrayBubble(this, items, bubble_type);
+    system_bubble_.reset(new internal::SystemBubbleWrapper(
+        this, bubble, tray_container(), &init_params));
   }
   // Save height of default view for creating detailed views directly.
   if (!detailed)
-    default_bubble_height_ = bubble_->bubble_view()->height();
+    default_bubble_height_ = system_bubble_->bubble_view()->height();
 
   if (detailed && items.size() > 0)
     detailed_item_ = items[0];
   else
     detailed_item_ = NULL;
 
   UpdateNotificationBubble();  // State changed, re-create notifications.
   status_area_widget()->SetHideWebNotifications(true);
   Shell::GetInstance()->shelf()->UpdateAutoHideState();
 }
 
 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)) {
+      HasSystemBubbleType(SystemTrayBubble::BUBBLE_TYPE_DEFAULT)) {
     DestroyNotificationBubble();
     return;
   }
-  if (bubble_.get() &&
-      bubble_->bubble_type() == SystemTrayBubble::BUBBLE_TYPE_DETAILED) {
+  // Destroy the existing bubble before constructing a new one.
+  notification_bubble_.reset();
+  SystemTrayBubble* notification_bubble;
+  if (HasSystemBubbleType(SystemTrayBubble::BUBBLE_TYPE_DETAILED)) {
     // Skip notifications for any currently displayed detailed item.
     std::vector<SystemTrayItem*> items;
     for (std::vector<SystemTrayItem*>::iterator iter =
              notification_items_.begin();
          iter != notification_items_.end(); ++ iter) {
       if (*iter != detailed_item_)
         items.push_back(*iter);
     }
     if (items.empty()) {
       DestroyNotificationBubble();
       return;
     }
-    notification_bubble_.reset(new SystemTrayBubble(
-        this, items, SystemTrayBubble::BUBBLE_TYPE_NOTIFICATION));
+    notification_bubble = new SystemTrayBubble(
+        this, items, SystemTrayBubble::BUBBLE_TYPE_NOTIFICATION);
   } else {
     // Show all notifications.
-    notification_bubble_.reset(new SystemTrayBubble(
-        this, notification_items_, SystemTrayBubble::BUBBLE_TYPE_NOTIFICATION));
+    notification_bubble = new SystemTrayBubble(
+        this, notification_items_, SystemTrayBubble::BUBBLE_TYPE_NOTIFICATION);
   }
   views::View* anchor;
   TrayBubbleView::AnchorType anchor_type;
-  if (bubble_.get()) {
-    anchor = bubble_->bubble_view();
+  if (system_bubble_.get()) {
+    anchor = system_bubble_->bubble_view();
     anchor_type = TrayBubbleView::ANCHOR_TYPE_BUBBLE;
   } else {
     anchor = tray_container();
     anchor_type = TrayBubbleView::ANCHOR_TYPE_TRAY;
   }
   TrayBubbleView::InitParams init_params(anchor_type,
                                          GetAnchorAlignment(),
                                          kTrayPopupWidth);
   init_params.top_color = kBackgroundColor;
   init_params.arrow_color = kBackgroundColor;
   init_params.arrow_offset = GetTrayXOffset(notification_items_[0]);
-  user::LoginStatus login_status =
-      Shell::GetInstance()->tray_delegate()->GetUserLoginStatus();
-  notification_bubble_->InitView(anchor, login_status, &init_params);
-  if (notification_bubble_->bubble_view()->child_count() == 0) {
+  notification_bubble_.reset(new internal::SystemBubbleWrapper(
+      this, notification_bubble, anchor, &init_params));
+
+  if (notification_bubble->bubble_view()->child_count() == 0) {
     // It is possible that none of the items generated actual notifications.
     DestroyNotificationBubble();
     return;
   }
   if (hide_notifications_)
-    notification_bubble_->SetVisible(false);
+    notification_bubble->SetVisible(false);
   else
     status_area_widget()->SetHideWebNotifications(true);
 }
 
 void SystemTray::Initialize() {
   internal::TrayBackgroundView::Initialize();
   CreateItems();
 }
 
 void SystemTray::SetShelfAlignment(ShelfAlignment alignment) {
   if (alignment == shelf_alignment())
     return;
   internal::TrayBackgroundView::SetShelfAlignment(alignment);
   UpdateAfterShelfAlignmentChange(alignment);
   // Destroy any existing bubble so that it is rebuilt correctly.
-  bubble_.reset();
+  system_bubble_.reset();
   // Rebuild any notification bubble.
   if (notification_bubble_.get()) {
     notification_bubble_.reset();
     UpdateNotificationBubble();
   }
 }
 
 void SystemTray::AnchorUpdated() {
   if (notification_bubble_.get()) {
     notification_bubble_->bubble_view()->UpdateBubble();
     // Ensure that the notification buble is above the launcher/status area.
     notification_bubble_->bubble_view()->GetWidget()->StackAtTop();
   }
-  if (bubble_.get())
-    bubble_->bubble_view()->UpdateBubble();
+  if (system_bubble_.get())
+    system_bubble_->bubble_view()->UpdateBubble();
 }
 
-string16 SystemTray::GetAccessibleName() {
+string16 SystemTray::GetAccessibleNameForTray() {
   return l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_ACCESSIBLE_NAME);
 }
 
 void SystemTray::HideBubbleWithView(const TrayBubbleView* bubble_view) {
-  if (bubble_.get() && bubble_view == bubble_->bubble_view()) {
-    DestroyBubble();
+  if (system_bubble_.get() && bubble_view == system_bubble_->bubble_view()) {
+    DestroySystemBubble();
     UpdateNotificationBubble();  // State changed, re-create notifications.
     Shell::GetInstance()->shelf()->UpdateAutoHideState();
   } else if (notification_bubble_.get() &&
              bubble_view == notification_bubble_->bubble_view()) {
     DestroyNotificationBubble();
   }
 }
 
 bool SystemTray::ClickedOutsideBubble() {
-  if (!bubble_.get() ||
-      bubble_->bubble_type() == SystemTrayBubble::BUBBLE_TYPE_NOTIFICATION) {
+  if (!system_bubble_.get())
     return false;
+  HideBubbleWithView(system_bubble_->bubble_view());
+  return true;
+}
+
+void SystemTray::BubbleViewDestroyed() {
+  if (system_bubble_.get()) {
+    system_bubble_->bubble()->DestroyItemViews();
+    system_bubble_->bubble()->BubbleViewDestroyed();
   }
-  HideBubbleWithView(bubble_->bubble_view());
-  return true;
+}
+
+void SystemTray::OnMouseEnteredView() {
+  if (system_bubble_.get())
+    system_bubble_->bubble()->StopAutoCloseTimer();
+}
+
+void SystemTray::OnMouseExitedView() {
+  if (system_bubble_.get())
+    system_bubble_->bubble()->RestartAutoCloseTimer();
+}
+
+string16 SystemTray::GetAccessibleNameForBubble() {
+  return GetAccessibleNameForTray();
+}
+
+gfx::Rect SystemTray::GetAnchorRect(
+    views::Widget* anchor_widget,
+    TrayBubbleView::AnchorType anchor_type,
+    TrayBubbleView::AnchorAlignment anchor_alignment) {
+  return GetBubbleAnchorRect(anchor_widget, anchor_type, anchor_alignment);
+}
+
+void SystemTray::HideBubble(const TrayBubbleView* bubble_view) {
+  HideBubbleWithView(bubble_view);
 }
 
 bool SystemTray::PerformAction(const ui::Event& event) {
   // If we're already showing the default view, hide it; otherwise, show it
   // (and hide any popup that's currently shown).
-  if (bubble_.get() &&
-      bubble_->bubble_type() == SystemTrayBubble::BUBBLE_TYPE_DEFAULT) {
-    bubble_->Close();
+  if (HasSystemBubbleType(SystemTrayBubble::BUBBLE_TYPE_DEFAULT)) {
+    system_bubble_->bubble()->Close();
   } else {
     int arrow_offset = TrayBubbleView::InitParams::kArrowDefaultOffset;
     if (event.IsMouseEvent() || event.type() == ui::ET_GESTURE_TAP) {
       const ui::LocatedEvent& located_event =
           static_cast<const ui::LocatedEvent&>(event);
       if (shelf_alignment() == SHELF_ALIGNMENT_BOTTOM) {
         gfx::Point point(located_event.x(), 0);
         ConvertPointToWidget(this, &point);
         arrow_offset = point.x();
       }
     }
     ShowDefaultViewWithOffset(BUBBLE_CREATE_NEW, arrow_offset);
   }
   return true;
 }
 
 }  // namespace ash