Extract the view of control buttons on notification into a separated class

ui/arc/notification/arc_notification_content_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_notification_content_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 "ui/accessibility/ax_action_data.h"
 #include "ui/accessibility/ax_node_data.h"
 #include "ui/arc/notification/arc_notification_surface.h"
 #include "ui/arc/notification/arc_notification_view.h"
 #include "ui/base/l10n/l10n_util.h"
-#include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/events/event_handler.h"
-#include "ui/gfx/animation/linear_animation.h"
-#include "ui/gfx/animation/tween.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/transform.h"
 #include "ui/message_center/message_center_style.h"
+#include "ui/message_center/views/notification_control_buttons_view.h"
 #include "ui/message_center/views/toast_contents_view.h"
 #include "ui/strings/grit/ui_strings.h"
-#include "ui/views/background.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 {
 
 namespace {
 
-// This value should be the same as the duration of reveal animation of
-// the settings view of an Android notification.
-constexpr int kBackgroundColorChangeDuration = 360;
-
 SkColor GetControlButtonBackgroundColor(
     const mojom::ArcNotificationShownContents& shown_contents) {
   if (shown_contents == mojom::ArcNotificationShownContents::CONTENTS_SHOWN)
     return message_center::kControlButtonBackgroundColor;
   else
     return SK_ColorTRANSPARENT;
 }
 
 }  // namespace
 
@@ skipping 130 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(SlideHelper);
 };
 
 class ArcNotificationContentView::ContentViewDelegate
     : public ArcNotificationContentViewDelegate {
  public:
   explicit ContentViewDelegate(ArcNotificationContentView* owner)
       : owner_(owner) {}
 
   bool IsCloseButtonFocused() const override {
-    if (!owner_->close_button_)
+    if (!owner_->control_buttons_view_)
       return false;
-    return owner_->close_button_->HasFocus();
+    return owner_->control_buttons_view_->IsCloseButtonFocused();
   }
 
   void RequestFocusOnCloseButton() override {
-    if (owner_->close_button_)
-      owner_->close_button_->RequestFocus();
+    if (owner_->control_buttons_view_)
+      owner_->control_buttons_view_->RequestFocusOnCloseButton();
     owner_->UpdateControlButtonsVisibility();
   }
 
   void UpdateControlButtonsVisibility() override {
     owner_->UpdateControlButtonsVisibility();
   }
 
   void OnSlideChanged() override {
     if (owner_->slide_helper_)
       owner_->slide_helper_->Update();
   }
 
  private:
   ArcNotificationContentView* const owner_;
 
   DISALLOW_COPY_AND_ASSIGN(ContentViewDelegate);
 };
 
-ArcNotificationContentView::ControlButton::ControlButton(
-    ArcNotificationContentView* owner)
-    : message_center::PaddedButton(owner), owner_(owner) {
-  if (owner_->item_) {
-    SetBackground(views::CreateSolidBackground(
-        GetControlButtonBackgroundColor(owner_->item_->GetShownContents())));
-  } else {
-    SetBackground(views::CreateSolidBackground(
-        message_center::kControlButtonBackgroundColor));
-  }
-}
-
-void ArcNotificationContentView::ControlButton::OnFocus() {
-  message_center::PaddedButton::OnFocus();
-  owner_->UpdateControlButtonsVisibility();
-}
-
-void ArcNotificationContentView::ControlButton::OnBlur() {
-  message_center::PaddedButton::OnBlur();
-  owner_->UpdateControlButtonsVisibility();
-}
-
 // static, for ArcNotificationContentView::GetClassName().
 const char ArcNotificationContentView::kViewClassName[] =
     "ArcNotificationContentView";
 
 ArcNotificationContentView::ArcNotificationContentView(
     ArcNotificationItem* item)
     : item_(item),
       notification_key_(item->GetNotificationKey()),
       event_forwarder_(new EventForwarder(this)) {
   SetFocusBehavior(FocusBehavior::ALWAYS);
@@ skipping 32 matching lines @@
 const char* ArcNotificationContentView::GetClassName() const {
   return kViewClassName;
 }
 
 std::unique_ptr<ArcNotificationContentViewDelegate>
 ArcNotificationContentView::CreateContentViewDelegate() {
   return base::MakeUnique<ArcNotificationContentView::ContentViewDelegate>(
       this);
 }
 
-void ArcNotificationContentView::CreateCloseButton() {
-  DCHECK(control_buttons_view_);
-  DCHECK(item_);
-
-  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 ArcNotificationContentView::CreateSettingsButton() {
-  DCHECK(control_buttons_view_);
-  DCHECK(item_);
-
-  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_);
-}
-
 void ArcNotificationContentView::MaybeCreateFloatingControlButtons() {
   // 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. Further, if we are being destroyed (|item_| is null), don't
   // create the control buttons.
   if (!surface_ || !GetWidget() || !item_)
     return;
 
+  DCHECK(!control_buttons_view_);
+  DCHECK(!floating_control_buttons_widget_);
+
+  CHECK_EQ(ArcNotificationView::kViewClassName, parent()->GetClassName());
+  auto* notification_view = static_cast<ArcNotificationView*>(parent());
+
   // 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));
+  control_buttons_view_ =
+      new message_center::NotificationControlButtonsView(notification_view);
+  control_buttons_view_->SetPaintToLayer(ui::LAYER_TEXTURED);
+  control_buttons_view_->layer()->SetFillsBoundsOpaquely(false);
 
-  if (item_->IsOpeningSettingsSupported())
-    CreateSettingsButton();
-  if (!item_->GetPinned())
-    CreateCloseButton();
+  control_buttons_view_->SetBackgroundColor(
+      GetControlButtonBackgroundColor(item_->GetShownContents()));
+  control_buttons_view_->ShowSettingsButton(
+      item_->IsOpeningSettingsSupported());
+  control_buttons_view_->ShowCloseButton(!item_->GetPinned());
 
   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_->GetWindow();
 
   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 ArcNotificationContentView::SetSurface(ArcNotificationSurface* 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_->GetWindow()) {
     surface_->GetWindow()->RemoveObserver(this);
     surface_->GetWindow()->RemovePreTargetHandler(event_forwarder_.get());
 
     if (GetWidget() && surface_->IsAttached())
       surface_->Detach();
   }
 
   surface_ = surface;
@@ skipping 21 matching lines @@
     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 ArcNotificationContentView::UpdateControlButtonsVisibility() {
-  if (!floating_control_buttons_widget_)
+  if (!control_buttons_view_)
     return;
 
+  DCHECK(floating_control_buttons_widget_);
+
   const bool target_visiblity =
-      IsMouseHovered() || (close_button_ && close_button_->HasFocus()) ||
-      (settings_button_ && settings_button_->HasFocus());
+      IsMouseHovered() || (control_buttons_view_->IsCloseButtonFocused()) ||
+      (control_buttons_view_->IsSettingsButtonFocused());
+
   if (target_visiblity == floating_control_buttons_widget_->IsVisible())
     return;
 
   if (target_visiblity)
     floating_control_buttons_widget_->Show();
   else
     floating_control_buttons_widget_->Hide();
 }
 
 void ArcNotificationContentView::UpdatePinnedState() {
   if (!item_)
     return;
 
   // Surface is not attached yet.
   if (!control_buttons_view_)
     return;
 
-  if (item_->GetPinned() && close_button_) {
-    control_buttons_view_->RemoveChildView(close_button_.get());
-    close_button_.reset();
-    Layout();
-  } else if (!item_->GetPinned() && !close_button_) {
-    CreateCloseButton();
-    Layout();
-  }
+  control_buttons_view_->ShowCloseButton(!item_->GetPinned());
+  Layout();
 }
 
 void ArcNotificationContentView::UpdateSnapshot() {
   // Bail if we have a |surface_| because it controls the sizes and paints UI.
   if (surface_)
     return;
 
   UpdatePreferredSize();
   SchedulePaint();
 }
@@ skipping 15 matching lines @@
   // Creates slide helper after this view is added to its parent.
   slide_helper_.reset(new SlideHelper(this));
 
   // Invokes Update() in case surface is attached during a slide.
   slide_helper_->Update();
 
   // (Re-)create the floating buttons after |surface_| is attached to a widget.
   MaybeCreateFloatingControlButtons();
 }
 
-void ArcNotificationContentView::StartControlButtonsColorAnimation() {
-  if (control_button_color_animation_)
-    control_button_color_animation_->End();
-  control_button_color_animation_.reset(new gfx::LinearAnimation(this));
-  control_button_color_animation_->SetDuration(kBackgroundColorChangeDuration);
-  control_button_color_animation_->Start();
-}
-
-bool ArcNotificationContentView::ShouldUpdateControlButtonsColor() const {
-  // Don't update the control button color when we are about to be destroyed.
-  if (!item_)
-    return false;
-
-  if (settings_button_ &&
-      settings_button_->background()->get_color() !=
-          GetControlButtonBackgroundColor(item_->GetShownContents()))
-    return true;
-  if (close_button_ &&
-      close_button_->background()->get_color() !=
-          GetControlButtonBackgroundColor(item_->GetShownContents()))
-    return true;
-  return false;
-}
-
 void ArcNotificationContentView::UpdateAccessibleName() {
   // Don't update the accessible name when we are about to be destroyed.
   if (!item_)
     return;
 
   accessible_name_ = item_->GetAccessibleName();
 }
 
 void ArcNotificationContentView::ViewHierarchyChanged(
     const views::View::ViewHierarchyChangedDetails& details) {
@@ skipping 39 matching lines @@
   if (!surface_size.IsEmpty() && !contents_size.IsEmpty()) {
     transform.Scale(
         static_cast<float>(contents_size.width()) / surface_size.width(),
         static_cast<float>(contents_size.height()) / surface_size.height());
   }
 
   // Apply the transform to the surface content so that close button can
   // be positioned without the need to consider the transform.
   surface_->GetContentWindow()->SetTransform(transform);
 
-  if (!floating_control_buttons_widget_)
-    return;
+  if (control_buttons_view_) {
+    DCHECK(floating_control_buttons_widget_);
+    gfx::Rect control_buttons_bounds(contents_bounds);
+    int buttons_width = control_buttons_view_->GetPreferredSize().width();
+    int buttons_height = control_buttons_view_->GetPreferredSize().height();
 
-  gfx::Rect control_buttons_bounds(contents_bounds);
-  int buttons_width = 0;
-  int buttons_height = 0;
-  if (close_button_) {
-    buttons_width += close_button_->GetPreferredSize().width();
-    buttons_height = close_button_->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);
+    floating_control_buttons_widget_->SetBounds(control_buttons_bounds);
   }
-  if (settings_button_) {
-    buttons_width += settings_button_->GetPreferredSize().width();
-    buttons_height = settings_button_->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);
-  floating_control_buttons_widget_->SetBounds(control_buttons_bounds);
 
   UpdateControlButtonsVisibility();
 
   ash::wm::SnapWindowToPixelBoundary(surface_->GetWindow());
 }
 
 void ArcNotificationContentView::OnPaint(gfx::Canvas* canvas) {
   views::NativeViewHost::OnPaint(canvas);
 
   // Bail if there is a |surface_| or no item or no snapshot image.
@@ skipping 60 matching lines @@
 void ArcNotificationContentView::GetAccessibleNodeData(
     ui::AXNodeData* node_data) {
   node_data->role = ui::AX_ROLE_BUTTON;
   node_data->AddStringAttribute(
       ui::AX_ATTR_ROLE_DESCRIPTION,
       l10n_util::GetStringUTF8(
           IDS_MESSAGE_NOTIFICATION_SETTINGS_BUTTON_ACCESSIBLE_NAME));
   node_data->SetName(accessible_name_);
 }
 
-void ArcNotificationContentView::ButtonPressed(views::Button* sender,
-                                               const ui::Event& event) {
-  if (item_ && !item_->GetPinned() && sender == close_button_.get()) {
-    CHECK_EQ(ArcNotificationView::kViewClassName, parent()->GetClassName());
-    static_cast<ArcNotificationView*>(parent())->OnCloseButtonPressed();
-  }
-  if (item_ && settings_button_ && sender == settings_button_) {
-    item_->OpenSettings();
-  }
-}
-
 void ArcNotificationContentView::OnWindowBoundsChanged(
     aura::Window* window,
     const gfx::Rect& old_bounds,
     const gfx::Rect& new_bounds) {
   if (in_layout_)
     return;
 
   UpdatePreferredSize();
   Layout();
 }
 
 void ArcNotificationContentView::OnWindowDestroying(aura::Window* window) {
   SetSurface(nullptr);
 }
 
 void ArcNotificationContentView::OnItemDestroying() {
   item_->RemoveObserver(this);
   item_ = nullptr;
 
   // Reset |surface_| with |item_| since no one is observing the |surface_|
   // after |item_| is gone and this view should be removed soon.
   SetSurface(nullptr);
 }
 
 void ArcNotificationContentView::OnItemUpdated() {
   UpdateAccessibleName();
   UpdatePinnedState();
   UpdateSnapshot();
-  if (ShouldUpdateControlButtonsColor())
-    StartControlButtonsColorAnimation();
+  if (control_buttons_view_) {
+    DCHECK(floating_control_buttons_widget_);
+    control_buttons_view_->SetBackgroundColor(
+        GetControlButtonBackgroundColor(item_->GetShownContents()));
+  }
 }
 
 void ArcNotificationContentView::OnNotificationSurfaceAdded(
     ArcNotificationSurface* surface) {
   if (surface->GetNotificationKey() != notification_key_)
     return;
 
   SetSurface(surface);
 }
 
 void ArcNotificationContentView::OnNotificationSurfaceRemoved(
     ArcNotificationSurface* surface) {
   if (surface->GetNotificationKey() != notification_key_)
     return;
 
   SetSurface(nullptr);
 }
 
-void ArcNotificationContentView::AnimationEnded(
-    const gfx::Animation* animation) {
-  DCHECK_EQ(animation, control_button_color_animation_.get());
-  control_button_color_animation_.reset();
-}
-
-void ArcNotificationContentView::AnimationProgressed(
-    const gfx::Animation* animation) {
-  DCHECK_EQ(animation, control_button_color_animation_.get());
-
-  if (item_) {
-    const SkColor target =
-        GetControlButtonBackgroundColor(item_->GetShownContents());
-    const SkColor start =
-        target == message_center::kControlButtonBackgroundColor
-            ? SK_ColorTRANSPARENT
-            : message_center::kControlButtonBackgroundColor;
-    const SkColor current_color = gfx::Tween::ColorValueBetween(
-        animation->GetCurrentValue(), start, target);
-    if (settings_button_) {
-      settings_button_->SetBackground(
-          views::CreateSolidBackground(current_color));
-      settings_button_->SchedulePaint();
-    }
-    if (close_button_) {
-      close_button_->SetBackground(views::CreateSolidBackground(current_color));
-      close_button_->SchedulePaint();
-    }
-  }
-}
-
 }  // namespace arc