Add NetworkNotificationView to tray_network.

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/shell_window_ids.h"
 #include "ash/system/tray/system_tray.h"
 #include "ash/system/tray/system_tray_delegate.h"
@@ skipping 29 matching lines @@
 const int kSystemTrayBubbleHorizontalInset = 1;
 const int kSystemTrayBubbleVerticalInset = 1;
 
 const int kArrowHeight = 10;
 const int kArrowWidth = 20;
 const int kArrowPaddingFromRight = 20;
 const int kMinArrowOffset = 12;
 
 const int kAnimationDurationForPopupMS = 200;
 
+// When showing a detailed view directly (e.g. from a notification), we may not
+// know the height of the default view, or the default view may be too small,
+// so pick a reasonable max height.
+const int kDetailedBubbleMaxHeight = kTrayPopupItemHeight * 5;

[sadrul, 2012/05/22 19:05:17]

Let's call this kNotificationBubbleMaxHeight. I don't think we need to worry
about this for detailed views.

[stevenjb, 2012/05/22 22:39:00]

This has nothing to do with notifications, it only applies to sizing the
detailed view when opened directly.

Currently, when we open the detailed view, it is always opened from the default
view, and we re-use the bubble so the height is set to the height of the default
view, which is what we want.

When we click on a notification, we want to open the detailed view directly. If
we have already opened the default view and set default_bubble_height_ in
SystemTray, we use that height, but if we have not (i.e. we receive a
notification before opening the system tray), we need a default height to use.
Also, if we ever have a configuration with fewer than 4 tray items (+ the
header), the view would be too small, so we also use this as a minimum height
for the detailed view.

Attempted to clarify the comment.

+
 const SkColor kShadowColor = SkColorSetARGB(0xff, 0, 0, 0);
 
 void DrawBlurredShadowAroundView(gfx::Canvas* canvas,
                                  int top,
                                  int bottom,
                                  int width,
                                  const gfx::Insets& inset) {
   SkPath path;
   path.incReserve(4);
   path.moveTo(SkIntToScalar(inset.left() + kShadowThickness),
@@ skipping 195 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(SystemTrayBubbleBorder);
 };
 
 }  // namespace
 
 namespace internal {
 
 // SystemTrayBubbleView
 
-SystemTrayBubbleView::SystemTrayBubbleView(views::View* anchor,
+SystemTrayBubbleView::SystemTrayBubbleView(
+    views::View* anchor,
     views::BubbleBorder::ArrowLocation arrow_location,
     SystemTrayBubble* host,
     bool can_activate)
     : views::BubbleDelegateView(anchor, arrow_location),
       host_(host),
-      can_activate_(can_activate) {
+      can_activate_(can_activate),
+      max_height_(0) {
   set_margin(0);
   set_parent_window(ash::Shell::GetInstance()->GetContainer(
       ash::internal::kShellWindowId_SettingBubbleContainer));
   set_notify_enter_exit_on_child(true);
 }
 
 SystemTrayBubbleView::~SystemTrayBubbleView() {
   // Inform host items (models) that their views are being destroyed.
   if (host_)
     host_->DestroyItemViews();
@@ skipping 46 matching lines @@
         IDS_ASH_STATUS_TRAY_ACCESSIBLE_NAME);
   }
 }
 
 bool SystemTrayBubbleView::CanActivate() const {
   return can_activate_;
 }
 
 gfx::Size SystemTrayBubbleView::GetPreferredSize() {
   gfx::Size size = views::BubbleDelegateView::GetPreferredSize();
-  return gfx::Size(kTrayPopupWidth, size.height());
+  int height = size.height();
+  if (max_height_ != 0 && height > max_height_)
+    height = max_height_;
+  return gfx::Size(kTrayPopupWidth, height);
 }
 
 void SystemTrayBubbleView::OnMouseEntered(const views::MouseEvent& event) {
   if (host_)
     host_->StopAutoCloseTimer();
 }
 
 void SystemTrayBubbleView::OnMouseExited(const views::MouseEvent& event) {
   if (host_)
     host_->RestartAutoCloseTimer();
 }
 
 // SystemTrayBubble::InitParams
 SystemTrayBubble::InitParams::InitParams(
     SystemTrayBubble::AnchorType anchor_type)
     : anchor(NULL),
       anchor_type(anchor_type),
       can_activate(false),
       login_status(ash::user::LOGGED_IN_NONE),
-      arrow_offset(kArrowPaddingFromRight + kArrowWidth / 2) {
+      arrow_offset(kArrowPaddingFromRight + kArrowWidth / 2),
+      max_height(0) {
 }
 
 // SystemTrayBubble
 
 SystemTrayBubble::SystemTrayBubble(
     ash::SystemTray* tray,
     const std::vector<ash::SystemTrayItem*>& items,
     BubbleType bubble_type)
     : tray_(tray),
       bubble_view_(NULL),
@@ skipping 24 matching lines @@
     const std::vector<ash::SystemTrayItem*>& items,
     BubbleType bubble_type) {
   DestroyItemViews();
   bubble_view_->RemoveAllChildViews(true);
 
   items_ = items;
   bubble_type_ = bubble_type;
   CreateItemViews(Shell::GetInstance()->tray_delegate()->GetUserLoginStatus());
   bubble_widget_->GetContentsView()->Layout();
   // Make sure that the bubble is large enough for the default view.
-  if (bubble_type_ == BUBBLE_TYPE_DEFAULT)
+  if (bubble_type_ == BUBBLE_TYPE_DEFAULT) {
+    bubble_view_->set_max_height(0);  // Clear max height limit.
     bubble_view_->SizeToContents();
+  }
 }
 
 void SystemTrayBubble::InitView(const InitParams& init_params) {
   DCHECK(bubble_view_ == NULL);
   anchor_type_ = init_params.anchor_type;
   views::BubbleBorder::ArrowLocation arrow_location;
   if (anchor_type_ == ANCHOR_TYPE_TRAY) {
     if (tray_->shelf_alignment() == SHELF_ALIGNMENT_BOTTOM) {
       arrow_location = views::BubbleBorder::BOTTOM_RIGHT;
     } else if (tray_->shelf_alignment() == SHELF_ALIGNMENT_LEFT) {
       arrow_location = views::BubbleBorder::LEFT_BOTTOM;
     } else {
       arrow_location = views::BubbleBorder::RIGHT_BOTTOM;
     }
   } else {
     arrow_location = views::BubbleBorder::NONE;
   }
   bubble_view_ = new SystemTrayBubbleView(
       init_params.anchor, arrow_location, this, init_params.can_activate);
   if (bubble_type_ == BUBBLE_TYPE_NOTIFICATION)
     bubble_view_->set_close_on_deactivate(false);
+  int max_height = init_params.max_height;
+  if (bubble_type_ == BUBBLE_TYPE_DETAILED &&
+      max_height < kDetailedBubbleMaxHeight)
+    max_height = kDetailedBubbleMaxHeight;
+  bubble_view_->set_max_height(max_height);
 
   CreateItemViews(init_params.login_status);
 
   DCHECK(bubble_widget_ == NULL);
   bubble_widget_ = views::BubbleDelegateView::CreateBubble(bubble_view_);
 
   // Must occur after call to CreateBubble()
   bubble_view_->SetAlignment(views::BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE);
   bubble_widget_->non_client_view()->frame_view()->set_background(NULL);
   SystemTrayBubbleBorder* bubble_border = new SystemTrayBubbleBorder(
@@ skipping 139 matching lines @@
 void SystemTrayBubble::OnWidgetVisibilityChanged(views::Widget* widget,
                                                  bool visible) {
   if (!visible)
     MessageLoopForUI::current()->RemoveObserver(this);
   else
     MessageLoopForUI::current()->AddObserver(this);
 }
 
 }  // namespace internal
 }  // namespace ash