Re-factor Ash Message Center code part 2/4

ash/system/tray/system_tray_bubble.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_bubble.h"
 
 #include "ash/shell.h"
 #include "ash/system/tray/system_tray.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 "base/message_loop.h"
 #include "ui/aura/window.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/canvas.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
@@ skipping 98 matching lines @@
 namespace internal {
 
 // SystemTrayBubble
 
 SystemTrayBubble::SystemTrayBubble(
     ash::SystemTray* tray,
     const std::vector<ash::SystemTrayItem*>& items,
     BubbleType bubble_type)
     : tray_(tray),
       bubble_view_(NULL),
-      bubble_widget_(NULL),
       items_(items),
       bubble_type_(bubble_type),
       autoclose_delay_(0) {
 }
 
 SystemTrayBubble::~SystemTrayBubble() {
   DestroyItemViews();
   // Reset the host pointer in bubble_view_ in case its destruction is deferred.
   if (bubble_view_)
-    bubble_view_->reset_host();
-  if (bubble_widget_) {
-    bubble_widget_->RemoveObserver(this);
-    // This triggers the destruction of bubble_view_.
-    bubble_widget_->Close();
-  }
+    bubble_view_->reset_delegate();
 }
 
 void SystemTrayBubble::UpdateView(
     const std::vector<ash::SystemTrayItem*>& items,
     BubbleType bubble_type) {
   DCHECK(bubble_type != BUBBLE_TYPE_NOTIFICATION);
   DCHECK(bubble_type != bubble_type_);
 
   const int kSwipeDelayMS = 150;
   base::TimeDelta swipe_duration =
@@ skipping 47 matching lines @@
   items_ = items;
   bubble_type_ = bubble_type;
   CreateItemViews(Shell::GetInstance()->tray_delegate()->GetUserLoginStatus());
 
   // Close bubble view if we failed to create the item view.
   if (!bubble_view_->has_children()) {
     Close();
     return;
   }
 
-  bubble_widget_->GetContentsView()->Layout();
+  bubble_view_->GetWidget()->GetContentsView()->Layout();
   // Make sure that the bubble is large enough for the default view.
   if (bubble_type_ == BUBBLE_TYPE_DEFAULT) {
     bubble_view_->SetMaxHeight(0);  // Clear max height limit.
   }
 
   // When transitioning from default view to detailed view, animate the new
   // view (slide in from the right).
   if (bubble_type == BUBBLE_TYPE_DETAILED) {
     ui::Layer* new_layer = bubble_view_->layer();
     gfx::Rect bounds = new_layer->bounds();
     ui::Transform transform;
     transform.SetTranslateX(bounds.width());
     new_layer->SetTransform(transform);
     {
       ui::ScopedLayerAnimationSettings settings(new_layer->GetAnimator());
       settings.AddObserver(new AnimationObserverDeleteLayer(layer));
       settings.SetTransitionDuration(swipe_duration);
       settings.SetTweenType(ui::Tween::EASE_OUT);
       new_layer->SetTransform(ui::Transform());
     }
   }
 }
 
 void SystemTrayBubble::InitView(views::View* anchor,
-                                TrayBubbleView::InitParams init_params,
-                                user::LoginStatus login_status) {
+                                user::LoginStatus login_status,
+                                TrayBubbleView::InitParams* init_params) {
   DCHECK(bubble_view_ == NULL);
 
   if (bubble_type_ == BUBBLE_TYPE_DETAILED &&
-      init_params.max_height < kDetailedBubbleMaxHeight) {
-    init_params.max_height = kDetailedBubbleMaxHeight;
+      init_params->max_height < kDetailedBubbleMaxHeight) {
+    init_params->max_height = kDetailedBubbleMaxHeight;
   } else if (bubble_type_ == BUBBLE_TYPE_NOTIFICATION) {
-    init_params.close_on_deactivate = false;
+    init_params->close_on_deactivate = false;
   }
-  bubble_view_ = TrayBubbleView::Create(anchor, this, init_params);
+  bubble_view_ = TrayBubbleView::Create(
+      tray_->GetBubbleWindowContainer(), anchor, this, init_params);
 
   CreateItemViews(login_status);
 
-  DCHECK(bubble_widget_ == NULL);
-  bubble_widget_ = views::BubbleDelegateView::CreateBubble(bubble_view_);
-  bubble_widget_->AddObserver(this);
-
-  InitializeAndShowBubble(bubble_widget_, bubble_view_, tray_);
+  bubble_wrapper_.reset(new internal::TrayBubbleWrapper(tray_, bubble_view_));
 }
 
 void SystemTrayBubble::BubbleViewDestroyed() {
   DestroyItemViews();
   bubble_view_ = NULL;
 }
 
 void SystemTrayBubble::OnMouseEnteredView() {
   StopAutoCloseTimer();
 }
 
 void SystemTrayBubble::OnMouseExitedView() {
   RestartAutoCloseTimer();
 }
 
-void SystemTrayBubble::OnClickedOutsideView() {
-  if (bubble_type_ != BUBBLE_TYPE_NOTIFICATION)
-    bubble_widget_->Close();
-}
-
 string16 SystemTrayBubble::GetAccessibleName() {
   return tray_->GetAccessibleName();
 }
 
+gfx::Rect SystemTrayBubble::GetAnchorRect(
+    views::Widget* anchor_widget,
+    TrayBubbleView::AnchorType anchor_type,
+    TrayBubbleView::AnchorAlignment anchor_alignment) {
+  return tray_->GetAnchorRect(anchor_widget, anchor_type, anchor_alignment);
+}
+
 void SystemTrayBubble::DestroyItemViews() {
   for (std::vector<ash::SystemTrayItem*>::iterator it = items_.begin();
        it != items_.end();
        ++it) {
     switch (bubble_type_) {
       case BUBBLE_TYPE_DEFAULT:
         (*it)->DestroyDefaultView();
         break;
       case BUBBLE_TYPE_DETAILED:
         (*it)->DestroyDetailedView();
@@ skipping 18 matching lines @@
 void SystemTrayBubble::StopAutoCloseTimer() {
   autoclose_.Stop();
 }
 
 void SystemTrayBubble::RestartAutoCloseTimer() {
   if (autoclose_delay_)
     StartAutoCloseTimer(autoclose_delay_);
 }
 
 void SystemTrayBubble::Close() {
-  if (bubble_widget_)
-    bubble_widget_->Close();
+  tray_->HideBubble(bubble_view());
 }
 
 void SystemTrayBubble::SetVisible(bool is_visible) {
-  if (!bubble_widget_)
+  if (!bubble_view_)
     return;
+  views::Widget* bubble_widget = bubble_view_->GetWidget();
   if (is_visible)
-    bubble_widget_->Show();
+    bubble_widget->Show();
   else
-    bubble_widget_->Hide();
+    bubble_widget->Hide();
 }
 
 bool SystemTrayBubble::IsVisible() {
-  return bubble_widget_ && bubble_widget_->IsVisible();
+  return bubble_view() && bubble_view()->GetWidget()->IsVisible();
 }
 
 void SystemTrayBubble::CreateItemViews(user::LoginStatus login_status) {
   for (std::vector<ash::SystemTrayItem*>::iterator it = items_.begin();
        it != items_.end();
        ++it) {
     views::View* view = NULL;
     switch (bubble_type_) {
       case BUBBLE_TYPE_DEFAULT:
         view = (*it)->CreateDefaultView(login_status);
         break;
       case BUBBLE_TYPE_DETAILED:
         view = (*it)->CreateDetailedView(login_status);
         break;
       case BUBBLE_TYPE_NOTIFICATION:
         view = (*it)->CreateNotificationView(login_status);
         break;
     }
     if (view) {
       bubble_view_->AddChildView(new TrayPopupItemContainer(
           view, tray_->shelf_alignment(), bubble_type_ == BUBBLE_TYPE_DEFAULT));
     }
   }
 }
 
-void SystemTrayBubble::OnWidgetClosing(views::Widget* widget) {
-  CHECK_EQ(bubble_widget_, widget);
-  bubble_widget_ = NULL;
-  tray_->RemoveBubble(this);
-}
-
 }  // namespace internal
 }  // namespace ash