Show the settings button on a pinned notification.

ui/arc/notification/arc_custom_notification_view.cc

 // Copyright 2016 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/arc/notification/arc_custom_notification_view.h"
 
 #include "ash/wm/window_util.h"
 #include "base/auto_reset.h"
 #include "base/memory/ptr_util.h"
 #include "components/exo/notification_surface.h"
 #include "components/exo/surface.h"
-#include "third_party/skia/include/core/SkColor.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/layer_animation_observer.h"
-#include "ui/display/screen.h"
 #include "ui/events/event_handler.h"
 #include "ui/gfx/canvas.h"
-#include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/transform.h"
 #include "ui/message_center/message_center_style.h"
 #include "ui/message_center/views/custom_notification_view.h"
-#include "ui/message_center/views/padded_button.h"
 #include "ui/message_center/views/toast_contents_view.h"
-#include "ui/resources/grit/ui_resources.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/focus/focus_manager.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/views/painter.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/widget/widget.h"
 #include "ui/wm/core/window_util.h"
 
 namespace arc {
 
 class ArcCustomNotificationView::EventForwarder : public ui::EventHandler {
@@ skipping 111 matching lines @@
   }
   void OnLayerAnimationScheduled(ui::LayerAnimationSequence* seq) override {}
 
   ArcCustomNotificationView* const owner_;
   bool sliding_ = false;
   std::unique_ptr<ui::LayerTreeOwner> surface_copy_;
 
   DISALLOW_COPY_AND_ASSIGN(SlideHelper);
 };
 
-class ArcCustomNotificationView::ControlButton
-    : public message_center::PaddedButton {
- public:
-  explicit ControlButton(ArcCustomNotificationView* owner)
-      : message_center::PaddedButton(owner), owner_(owner) {}
-
-  void OnFocus() override {
-    message_center::PaddedButton::OnFocus();
-    owner_->UpdateControlButtonsVisibility();
-  }
-
-  void OnBlur() override {
-    message_center::PaddedButton::OnBlur();
-    owner_->UpdateControlButtonsVisibility();
-  }
-
-  void HideInkDrop() { AnimateInkDrop(views::InkDropState::HIDDEN, nullptr); }
-
- private:
-  ArcCustomNotificationView* const owner_;
-
-  DISALLOW_COPY_AND_ASSIGN(ControlButton);
-};
-
 class ArcCustomNotificationView::ContentViewDelegate
     : public message_center::CustomNotificationContentViewDelegate {
  public:
   explicit ContentViewDelegate(ArcCustomNotificationView* owner)
       : owner_(owner) {}
 
   bool IsCloseButtonFocused() const override {
-    if (owner_->close_button_ == nullptr)
+    if (!owner_->close_button_)
       return false;
     return owner_->close_button_->HasFocus();
   }
 
   void RequestFocusOnCloseButton() override {
     if (owner_->close_button_)
       owner_->close_button_->RequestFocus();
     owner_->UpdateControlButtonsVisibility();
   }
 
   bool IsPinned() const override {
     return owner_->item_->pinned();
   }
 
   void UpdateControlButtonsVisibility() override {
     owner_->UpdateControlButtonsVisibility();
   }
 
  private:
   ArcCustomNotificationView* const owner_;
 
   DISALLOW_COPY_AND_ASSIGN(ContentViewDelegate);
 };
 
+ArcCustomNotificationView::ControlButton::ControlButton(
+    ArcCustomNotificationView* owner)
+    : message_center::PaddedButton(owner), owner_(owner) {}
+
+void ArcCustomNotificationView::ControlButton::OnFocus() {
+  message_center::PaddedButton::OnFocus();
+  owner_->UpdateControlButtonsVisibility();
+}
+
+void ArcCustomNotificationView::ControlButton::OnBlur() {
+  message_center::PaddedButton::OnBlur();
+  owner_->UpdateControlButtonsVisibility();
+}
+
 ArcCustomNotificationView::ArcCustomNotificationView(
     ArcCustomNotificationItem* item)
     : item_(item),
       notification_key_(item->notification_key()),
       event_forwarder_(new EventForwarder(this)) {
   SetFocusBehavior(FocusBehavior::ALWAYS);
 
   item_->IncrementWindowRefCount();
   item_->AddObserver(this);
 
@@ skipping 17 matching lines @@
 
   if (ArcNotificationSurfaceManager::Get())
     ArcNotificationSurfaceManager::Get()->RemoveObserver(this);
 }
 
 std::unique_ptr<message_center::CustomNotificationContentViewDelegate>
 ArcCustomNotificationView::CreateContentViewDelegate() {
   return base::MakeUnique<ArcCustomNotificationView::ContentViewDelegate>(this);
 }
 
+void ArcCustomNotificationView::CreateCloseButton() {
+  DCHECK(control_buttons_view_);
+
+  close_button_ = base::MakeUnique<ControlButton>(this);
+  close_button_->SetImage(views::CustomButton::STATE_NORMAL,
+                          message_center::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();
+  control_buttons_view_->AddChildView(close_button_.get());
+}
+
 void ArcCustomNotificationView::CreateFloatingControlButtons() {
   // Floating close button is a transient child of |surface_| and also part
   // of the hosting widget's focus chain. It could only be created when both
   // are present.
   if (!surface_ || !GetWidget())
     return;
 
   // Creates the control_buttons_view_, which collects all control buttons into
   // a horizontal box.
   control_buttons_view_ = new views::View();
   control_buttons_view_->SetLayoutManager(
       new views::BoxLayout(views::BoxLayout::kHorizontal, 0, 0, 0));
 
   settings_button_ = new ControlButton(this);
   settings_button_->SetImage(views::CustomButton::STATE_NORMAL,
                              message_center::GetSettingsIcon());
   settings_button_->SetAccessibleName(l10n_util::GetStringUTF16(
       IDS_MESSAGE_NOTIFICATION_SETTINGS_BUTTON_ACCESSIBLE_NAME));
   settings_button_->SetTooltipText(l10n_util::GetStringUTF16(
       IDS_MESSAGE_NOTIFICATION_SETTINGS_BUTTON_ACCESSIBLE_NAME));
   control_buttons_view_->AddChildView(settings_button_);
 
-  close_button_ = new ControlButton(this);
-  close_button_->SetImage(views::CustomButton::STATE_NORMAL,
-                          message_center::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));
-  control_buttons_view_->AddChildView(close_button_);
+  CreateCloseButton();
 
   views::Widget::InitParams params(views::Widget::InitParams::TYPE_CONTROL);
   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.parent = surface_->window();
 
   floating_control_buttons_widget_.reset(new views::Widget);
   floating_control_buttons_widget_->Init(params);
   floating_control_buttons_widget_->SetContentsView(control_buttons_view_);
 
   // Put the close button into the focus chain.
   floating_control_buttons_widget_->SetFocusTraversableParent(
       GetWidget()->GetFocusTraversable());
   floating_control_buttons_widget_->SetFocusTraversableParentView(this);
 
   Layout();
 }
 
 void ArcCustomNotificationView::SetSurface(exo::NotificationSurface* surface) {
   if (surface_ == surface)
     return;
 
   // Reset |floating_control_buttons_widget_| when |surface_| is changed.
   floating_control_buttons_widget_.reset();
+  control_buttons_view_ = nullptr;
+  settings_button_ = nullptr;
+  close_button_.reset();
 
   if (surface_ && surface_->window()) {
     surface_->window()->RemoveObserver(this);
     surface_->window()->RemovePreTargetHandler(event_forwarder_.get());
   }
 
   surface_ = surface;
 
   if (surface_ && surface_->window()) {
     surface_->window()->AddObserver(this);
     surface_->window()->AddPreTargetHandler(event_forwarder_.get());
 
+    CreateFloatingControlButtons();
+
     if (GetWidget())
       AttachSurface();
   }
 }
 
 void ArcCustomNotificationView::UpdatePreferredSize() {
   gfx::Size preferred_size =
       surface_ ? surface_->GetSize() : item_ ? item_->snapshot().size()
                                              : gfx::Size();
   if (preferred_size.IsEmpty())
     return;
 
   if (preferred_size.width() != message_center::kNotificationWidth) {
     const float scale = static_cast<float>(message_center::kNotificationWidth) /
                         preferred_size.width();
     preferred_size.SetSize(message_center::kNotificationWidth,
                            preferred_size.height() * scale);
   }
 
   SetPreferredSize(preferred_size);
 }
 
 void ArcCustomNotificationView::UpdateControlButtonsVisibility() {
   if (!surface_ || !floating_control_buttons_widget_)
     return;
 
-  const bool target_visiblity =
-      surface_->window()->GetBoundsInScreen().Contains(
-          display::Screen::GetScreen()->GetCursorScreenPoint()) ||
-      close_button_->HasFocus() || settings_button_->HasFocus();
+  const bool target_visiblity = IsMouseHovered() ||
+                                (close_button_ && close_button_->HasFocus()) ||
+                                settings_button_->HasFocus();
   if (target_visiblity == floating_control_buttons_widget_->IsVisible())
     return;
 
   if (target_visiblity)
     floating_control_buttons_widget_->Show();
   else
     floating_control_buttons_widget_->Hide();
 }
 
 void ArcCustomNotificationView::UpdatePinnedState() {
   DCHECK(item_);
 
-  if (item_->pinned() && floating_control_buttons_widget_) {
-    floating_control_buttons_widget_.reset();
-  } else if (!item_->pinned() && !floating_control_buttons_widget_) {
-    CreateFloatingControlButtons();
+  if (item_->pinned() && close_button_) {
+    control_buttons_view_->RemoveChildView(close_button_.get());
+    close_button_.reset();
+    Layout();
+  } else if (!item_->pinned() && !close_button_) {
+    CreateCloseButton();
+    Layout();
   }
 }
 
 void ArcCustomNotificationView::UpdateSnapshot() {
   // Bail if we have a |surface_| because it controls the sizes and paints UI.
   if (surface_)
     return;
 
   UpdatePreferredSize();
   SchedulePaint();
@@ skipping 69 matching lines @@
   }
 
   // Apply the transform to the surface content so that close button can
   // be positioned without the need to consider the transform.
   surface_->window()->children()[0]->SetTransform(transform);
 
   if (!floating_control_buttons_widget_)
     return;
 
   gfx::Rect control_buttons_bounds(contents_bounds);
-  const int buttons_width = close_button_->GetPreferredSize().width() +
-                            settings_button_->GetPreferredSize().width();
+  int buttons_width = 0;
+  if (close_button_)
+    buttons_width += close_button_->GetPreferredSize().width();
+  if (settings_button_)
+    buttons_width += settings_button_->GetPreferredSize().width();
   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_height(close_button_->GetPreferredSize().height());
+  control_buttons_bounds.set_height(
+      settings_button_->GetPreferredSize().height());
   control_buttons_bounds.set_width(buttons_width);
   floating_control_buttons_widget_->SetBounds(control_buttons_bounds);
 
   UpdateControlButtonsVisibility();
 
   ash::wm::SnapWindowToPixelBoundary(surface_->window());
 }
 
 void ArcCustomNotificationView::OnPaint(gfx::Canvas* canvas) {
   views::NativeViewHost::OnPaint(canvas);
@@ skipping 58 matching lines @@
 
 views::FocusTraversable* ArcCustomNotificationView::GetFocusTraversable() {
   if (floating_control_buttons_widget_)
     return static_cast<views::internal::RootView*>(
         floating_control_buttons_widget_->GetRootView());
   return nullptr;
 }
 
 void ArcCustomNotificationView::ButtonPressed(views::Button* sender,
                                               const ui::Event& event) {
-  if (item_ && !item_->pinned() && sender == close_button_) {
+  if (item_ && !item_->pinned() && sender == close_button_.get()) {
     CHECK_EQ(message_center::CustomNotificationView::kViewClassName,
              parent()->GetClassName());
     static_cast<message_center::CustomNotificationView*>(parent())
         ->OnCloseButtonPressed();
   }
   if (item_ && settings_button_ && sender == settings_button_) {
-    settings_button_->HideInkDrop();
     item_->OpenSettings();
   }
 }
 
 void ArcCustomNotificationView::OnWindowBoundsChanged(
     aura::Window* window,
     const gfx::Rect& old_bounds,
     const gfx::Rect& new_bounds) {
   if (in_layout_)
     return;
@@ skipping 30 matching lines @@
 
 void ArcCustomNotificationView::OnNotificationSurfaceRemoved(
     exo::NotificationSurface* surface) {
   if (surface->notification_id() != notification_key_)
     return;
 
   SetSurface(nullptr);
 }
 
 }  // namespace arc