Revert of Use shared NotificationControlButtonsView for non-arc notification buttons

ui/message_center/views/notification_view.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 "ui/message_center/views/notification_view.h"
 
 #include <stddef.h>
 
 #include "base/command_line.h"
 #include "base/macros.h"
@@ skipping 11 matching lines @@
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/text_elider.h"
 #include "ui/message_center/message_center.h"
 #include "ui/message_center/message_center_style.h"
 #include "ui/message_center/notification.h"
 #include "ui/message_center/notification_types.h"
 #include "ui/message_center/views/bounded_label.h"
 #include "ui/message_center/views/constants.h"
 #include "ui/message_center/views/message_center_controller.h"
 #include "ui/message_center/views/notification_button.h"
-#include "ui/message_center/views/notification_control_buttons_view.h"
 #include "ui/message_center/views/padded_button.h"
 #include "ui/message_center/views/proportional_image_view.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/strings/grit/ui_strings.h"
 #include "ui/views/background.h"
 #include "ui/views/border.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/controls/image_view.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/controls/progress_bar.h"
@@ skipping 91 matching lines @@
   for (int i = 0; i < child_count(); ++i)
     child_at(i)->SetVisible(visible);
 }
 
 }  // namespace
 
 namespace message_center {
 
 // NotificationView ////////////////////////////////////////////////////////////
 
+views::View* NotificationView::TargetForRect(views::View* root,
+                                             const gfx::Rect& rect) {
+  CHECK_EQ(root, this);
+
+  // TODO(tdanderson): Modify this function to support rect-based event
+  // targeting. Using the center point of |rect| preserves this function's
+  // expected behavior for the time being.
+  gfx::Point point = rect.CenterPoint();
+
+  // Want to return this for underlying views, otherwise GetCursor is not
+  // called. But buttons are exceptions, they'll have their own event handlings.
+  std::vector<views::View*> buttons(action_buttons_.begin(),
+                                    action_buttons_.end());
+  if (settings_button_view_)
+    buttons.push_back(settings_button_view_);
+  if (close_button())
+    buttons.push_back(close_button());
+
+  for (size_t i = 0; i < buttons.size(); ++i) {
+    gfx::Point point_in_child = point;
+    ConvertPointToTarget(this, buttons[i], &point_in_child);
+    if (buttons[i]->HitTestPoint(point_in_child))
+      return buttons[i]->GetEventHandlerForPoint(point_in_child);
+  }
+
+  return root;
+}
+
 void NotificationView::CreateOrUpdateViews(const Notification& notification) {
   CreateOrUpdateTitleView(notification);
   CreateOrUpdateMessageView(notification);
   CreateOrUpdateProgressBarView(notification);
   CreateOrUpdateListItemViews(notification);
   CreateOrUpdateIconView(notification);
   CreateOrUpdateSmallIconView(notification);
   CreateOrUpdateImageView(notification);
   CreateOrUpdateContextMessageView(notification);
+  CreateOrUpdateSettingsButtonView(notification);
   CreateOrUpdateActionButtonViews(notification);
 }
 
 NotificationView::NotificationView(MessageCenterController* controller,
                                    const Notification& notification)
     : MessageView(controller, notification),
       clickable_(notification.clickable()) {
   // Create the top_view_, which collects into a vertical box all content
   // at the top of the notification (to the right of the icon) except for the
   // close button.
   top_view_ = new views::View();
   top_view_->SetLayoutManager(
       new views::BoxLayout(views::BoxLayout::kVertical));
   top_view_->SetBorder(
       MakeEmptyBorder(kTextTopPadding - 8, 0, kTextBottomPadding - 5, 0));
   AddChildView(top_view_);
   // Create the bottom_view_, which collects into a vertical box all content
   // below the notification icon.
   bottom_view_ = new views::View();
   bottom_view_->SetLayoutManager(
       new views::BoxLayout(views::BoxLayout::kVertical));
   AddChildView(bottom_view_);
 
-  control_buttons_view_ = new NotificationControlButtonsView(this);
-  AddChildView(control_buttons_view_);
-
   views::ImageView* small_image_view = new views::ImageView();
   small_image_view->SetImageSize(gfx::Size(kSmallImageSize, kSmallImageSize));
   small_image_view->set_owned_by_client();
   small_image_view_.reset(small_image_view);
 
   CreateOrUpdateViews(notification);
 
   // Put together the different content and control views. Layering those allows
-  // for proper layout logic and it also allows the control buttons and small
+  // for proper layout logic and it also allows the close button and small
   // image to overlap the content as needed to provide large enough click and
   // touch areas (<http://crbug.com/168822> and <http://crbug.com/168856>).
   AddChildView(small_image_view_.get());
-  UpdateControlButtonsVisibilityWithNotification(notification);
+  CreateOrUpdateCloseButtonView(notification);
 
   SetEventTargeter(
       std::unique_ptr<views::ViewTargeter>(new views::ViewTargeter(this)));
   set_notify_enter_exit_on_child(true);
 }
 
 NotificationView::~NotificationView() {
 }
 
 gfx::Size NotificationView::CalculatePreferredSize() const {
@@ skipping 57 matching lines @@
     message_view_->SetLineLimit(GetMessageLineLimit(title_lines, width()));
 
   // Top views.
   int top_height = top_view_->GetHeightForWidth(content_width);
   top_view_->SetBounds(insets.left(), insets.top(), content_width, top_height);
 
   // Icon.
   icon_view_->SetBounds(insets.left(), insets.top(), kNotificationIconSize,
                         kNotificationIconSize);
 
-  // Control buttons (close and settings buttons).
-  gfx::Rect control_buttons_bounds(content_bounds);
-  int buttons_width = control_buttons_view_->GetPreferredSize().width();
-  int buttons_height = control_buttons_view_->GetPreferredSize().height();
-  control_buttons_bounds.set_x(control_buttons_bounds.right() - buttons_width -
-                               message_center::kControlButtonPadding);
-  control_buttons_bounds.set_y(control_buttons_bounds.y() +
-                               message_center::kControlButtonPadding);
-  control_buttons_bounds.set_width(buttons_width);
-  control_buttons_bounds.set_height(buttons_height);
-  control_buttons_view_->SetBoundsRect(control_buttons_bounds);
+  // Settings & Bottom views.
+  int bottom_y = insets.top() + std::max(top_height, kNotificationIconSize);
+  int bottom_height = bottom_view_->GetHeightForWidth(content_width);
+
+  if (settings_button_view_) {
+    const gfx::Size settings_size(settings_button_view_->GetPreferredSize());
+    int marginFromRight = settings_size.width() + kControlButtonPadding;
+    if (close_button_)
+      marginFromRight += close_button_->GetPreferredSize().width();
+    gfx::Rect settings_rect(insets.left() + content_width - marginFromRight,
+                            GetContentsBounds().y() + kControlButtonPadding,
+                            settings_size.width(), settings_size.height());
+    settings_button_view_->SetBoundsRect(settings_rect);
+  }
+
+  // Close button.
+  if (close_button_) {
+    gfx::Rect content_bounds = GetContentsBounds();
+    gfx::Size close_size(close_button_->GetPreferredSize());
+    gfx::Rect close_rect(
+        content_bounds.right() - close_size.width() - kControlButtonPadding,
+        content_bounds.y() + kControlButtonPadding, close_size.width(),
+        close_size.height());
+    close_button_->SetBoundsRect(close_rect);
+  }
 
   // Small icon.
   gfx::Size small_image_size(small_image_view_->GetPreferredSize());
   gfx::Rect small_image_rect(small_image_size);
   small_image_rect.set_origin(gfx::Point(
       content_bounds.right() - small_image_size.width() - kSmallImagePadding,
       content_bounds.bottom() - small_image_size.height() -
           kSmallImagePadding));
   small_image_view_->SetBoundsRect(small_image_rect);
 
-  // Bottom views.
-  int bottom_y = insets.top() + std::max(top_height, kNotificationIconSize);
-  int bottom_height = bottom_view_->GetHeightForWidth(content_width);
   bottom_view_->SetBounds(insets.left(), bottom_y,
                           content_width, bottom_height);
 }
 
 void NotificationView::OnFocus() {
   MessageView::OnFocus();
   ScrollRectToVisible(GetLocalBounds());
 }
 
 void NotificationView::ScrollRectToVisible(const gfx::Rect& rect) {
@@ skipping 22 matching lines @@
 void NotificationView::OnMouseExited(const ui::MouseEvent& event) {
   MessageView::OnMouseExited(event);
   UpdateControlButtonsVisibility();
 }
 
 void NotificationView::UpdateWithNotification(
     const Notification& notification) {
   MessageView::UpdateWithNotification(notification);
 
   CreateOrUpdateViews(notification);
-  UpdateControlButtonsVisibilityWithNotification(notification);
+  CreateOrUpdateCloseButtonView(notification);
   Layout();
   SchedulePaint();
 }
 
 void NotificationView::ButtonPressed(views::Button* sender,
                                      const ui::Event& event) {
   // Certain operations can cause |this| to be destructed, so copy the members
   // we send to other parts of the code.
   // TODO(dewittj): Remove this hack.
   std::string id(notification_id());
 
+  if (close_button_ && sender == close_button_.get()) {
+    // Warning: This causes the NotificationView itself to be deleted, so don't
+    // do anything afterwards.
+    OnCloseButtonPressed();
+    return;
+  }
+
+  if (sender == settings_button_view_) {
+    OnSettingsButtonPressed();
+    return;
+  }
+
   // See if the button pressed was an action button.
   for (size_t i = 0; i < action_buttons_.size(); ++i) {
     if (sender == action_buttons_[i]) {
       controller()->ClickOnNotificationButton(id, i);
       return;
     }
   }
-
-  NOTREACHED();
 }
 
 bool NotificationView::IsCloseButtonFocused() const {
-  return control_buttons_view_->IsCloseButtonFocused();
+  if (!close_button_)
+    return false;
+
+  const views::FocusManager* focus_manager = GetFocusManager();
+  return focus_manager &&
+         focus_manager->GetFocusedView() == close_button_.get();
 }
 
 void NotificationView::RequestFocusOnCloseButton() {
-  control_buttons_view_->RequestFocusOnCloseButton();
+  if (close_button_)
+    close_button_->RequestFocus();
 }
 
 void NotificationView::CreateOrUpdateTitleView(
     const Notification& notification) {
   if (notification.title().empty()) {
     // Deletion will also remove |title_view_| from its parent.
     delete title_view_;
     title_view_ = nullptr;
     return;
   }
@@ skipping 90 matching lines @@
     context_message_view_->SetLineHeight(kMessageLineHeight);
     context_message_view_->SetColors(message_center::kDimTextColor,
                                      kContextTextBackgroundColor);
     context_message_view_->SetBorder(MakeTextBorder(padding, 4, 0));
     top_view_->AddChildView(context_message_view_);
   } else {
     context_message_view_->SetText(message);
   }
 }
 
+void NotificationView::CreateOrUpdateSettingsButtonView(
+    const Notification& notification) {
+  delete settings_button_view_;
+  settings_button_view_ = nullptr;
+
+  if (!settings_button_view_ && notification.delegate() &&
+      notification.delegate()->ShouldDisplaySettingsButton()) {
+    PaddedButton* settings = new PaddedButton(this);
+    settings->SetImage(views::Button::STATE_NORMAL, GetSettingsIcon());
+    settings->SetAccessibleName(l10n_util::GetStringUTF16(
+        IDS_MESSAGE_NOTIFICATION_SETTINGS_BUTTON_ACCESSIBLE_NAME));
+    settings->SetTooltipText(l10n_util::GetStringUTF16(
+        IDS_MESSAGE_NOTIFICATION_SETTINGS_BUTTON_ACCESSIBLE_NAME));
+    settings_button_view_ = settings;
+    AddChildView(settings_button_view_);
+  }
+  UpdateControlButtonsVisibility();
+}
+
 void NotificationView::CreateOrUpdateProgressBarView(
     const Notification& notification) {
   if (notification.type() != NOTIFICATION_TYPE_PROGRESS) {
     // Deletion will also remove |progress_bar_view_| from its parent.
     delete progress_bar_view_;
     progress_bar_view_ = nullptr;
     return;
   }
 
   DCHECK(top_view_);
@@ skipping 131 matching lines @@
   if (new_buttons) {
     Layout();
     views::Widget* widget = GetWidget();
     if (widget != NULL) {
       widget->SetSize(widget->GetContentsView()->GetPreferredSize());
       GetWidget()->SynthesizeMouseMoveEvent();
     }
   }
 }
 
-void NotificationView::UpdateControlButtonsVisibilityWithNotification(
+void NotificationView::CreateOrUpdateCloseButtonView(
     const Notification& notification) {
-  control_buttons_view_->ShowSettingsButton(
-      notification.delegate() &&
-      notification.delegate()->ShouldDisplaySettingsButton());
-  control_buttons_view_->ShowCloseButton(!notification.pinned());
-  UpdateControlButtonsVisibility();
+  if (!notification.pinned() && !close_button_) {
+    close_button_ = base::MakeUnique<PaddedButton>(this);
+    close_button_->SetImage(views::Button::STATE_NORMAL, GetCloseIcon());
+    close_button_->SetAccessibleName(l10n_util::GetStringUTF16(
+        IDS_MESSAGE_CENTER_CLOSE_NOTIFICATION_BUTTON_ACCESSIBLE_NAME));
+    close_button_->SetTooltipText(l10n_util::GetStringUTF16(
+        IDS_MESSAGE_CENTER_CLOSE_NOTIFICATION_BUTTON_TOOLTIP));
+    close_button_->set_owned_by_client();
+    AddChildView(close_button_.get());
+    UpdateControlButtonsVisibility();
+  } else if (notification.pinned() && close_button_) {
+    close_button_.reset();
+  }
 }
 
 void NotificationView::UpdateControlButtonsVisibility() {
 #if defined(OS_CHROMEOS)
-  // On Chrome OS, the settings button and the close button are shown when:
-  // (1) the mouse is hovering on the notification.
-  // (2) the focus is on the control buttons.
+  // On Chrome OS, the settings button and the close button are shown only when
+  // the mouse is hovering on the notification.
   const bool target_visibility =
       IsMouseHovered() || HasFocus() ||
-      control_buttons_view_->IsCloseButtonFocused() ||
-      control_buttons_view_->IsSettingsButtonFocused();
+      (close_button_ &&
+       (close_button_->HasFocus() || close_button_->IsMouseHovered())) ||
+      (settings_button_view_ && (settings_button_view_->HasFocus() ||
+                                 settings_button_view_->IsMouseHovered()));
 #else
   // On non Chrome OS, the settings button and the close button are always
   // shown.
   const bool target_visibility = true;
 #endif
 
-  control_buttons_view_->SetVisible(target_visibility);
+  if (close_button_) {
+    if (target_visibility != close_button_->visible())
+      close_button_->SetVisible(target_visibility);
+  }
+
+  if (settings_button_view_) {
+    if (target_visibility != settings_button_view_->visible())
+      settings_button_view_->SetVisible(target_visibility);
+  }
 }
 
 int NotificationView::GetMessageLineLimit(int title_lines, int width) const {
   // Image notifications require that the image must be kept flush against
   // their icons, but we can allow more text if no image.
   int effective_title_lines = std::max(0, title_lines - 1);
   int line_reduction_from_title = (image_view_ ? 1 : 2) * effective_title_lines;
   if (!image_view_) {
     // Title lines are counted as twice as big as message lines for the purpose
     // of this calculation.
@@ skipping 24 matching lines @@
 
   return message_line_limit;
 }
 
 int NotificationView::GetMessageHeight(int width, int limit) const {
   return message_view_ ?
          message_view_->GetSizeForWidthAndLines(width, limit).height() : 0;
 }
 
 }  // namespace message_center