Add unittests of ArcCustomNotificationView

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/transform.h"
 #include "ui/message_center/message_center_style.h"
@@ skipping 80 matching lines @@
 
 class ArcNotificationContentView::SlideHelper
     : public ui::LayerAnimationObserver {
  public:
   explicit SlideHelper(ArcNotificationContentView* owner) : owner_(owner) {
     GetSlideOutLayer()->GetAnimator()->AddObserver(this);
 
     // Reset opacity to 1 to handle to case when the surface is sliding before
     // getting managed by this class, e.g. sliding in a popup before showing
     // in a message center view.
-    if (owner_->surface_ && owner_->surface_->window())
-      owner_->surface_->window()->layer()->SetOpacity(1.0f);
+    if (owner_->surface_ && owner_->surface_->GetWindow())
+      owner_->surface_->GetWindow()->layer()->SetOpacity(1.0f);
   }
   ~SlideHelper() override {
     if (GetSlideOutLayer())
       GetSlideOutLayer()->GetAnimator()->RemoveObserver(this);
   }
 
   void Update() {
     const bool has_animation =
         GetSlideOutLayer()->GetAnimator()->is_animating();
     const bool has_transform = !GetSlideOutLayer()->transform().IsIdentity();
@@ skipping 10 matching lines @@
   }
 
  private:
   // This is a temporary hack to address crbug.com/718965
   ui::Layer* GetSlideOutLayer() {
     ui::Layer* layer = owner_->parent()->layer();
     return layer ? layer : owner_->GetWidget()->GetLayer();
   }
 
   void OnSlideStart() {
-    if (!owner_->surface_ || !owner_->surface_->window())
+    if (!owner_->surface_ || !owner_->surface_->GetWindow())
       return;
-    surface_copy_ = ::wm::RecreateLayers(owner_->surface_->window());
+    surface_copy_ = ::wm::RecreateLayers(owner_->surface_->GetWindow());
     // |surface_copy_| is at (0, 0) in owner_->layer().
     surface_copy_->root()->SetBounds(gfx::Rect(surface_copy_->root()->size()));
     owner_->layer()->Add(surface_copy_->root());
-    owner_->surface_->window()->layer()->SetOpacity(0.0f);
+    owner_->surface_->GetWindow()->layer()->SetOpacity(0.0f);
   }
 
   void OnSlideEnd() {
-    if (!owner_->surface_ || !owner_->surface_->window())
+    if (!owner_->surface_ || !owner_->surface_->GetWindow())
       return;
-    owner_->surface_->window()->layer()->SetOpacity(1.0f);
+    owner_->surface_->GetWindow()->layer()->SetOpacity(1.0f);
     owner_->Layout();
     surface_copy_.reset();
   }
 
   // ui::LayerAnimationObserver
   void OnLayerAnimationEnded(ui::LayerAnimationSequence* seq) override {
     Update();
   }
   void OnLayerAnimationAborted(ui::LayerAnimationSequence* seq) override {
     Update();
@@ skipping 55 matching lines @@
 void ArcNotificationContentView::ControlButton::OnFocus() {
   message_center::PaddedButton::OnFocus();
   owner_->UpdateControlButtonsVisibility();
 }
 
 void ArcNotificationContentView::ControlButton::OnBlur() {
   message_center::PaddedButton::OnBlur();
   owner_->UpdateControlButtonsVisibility();
 }
 
+// static
+const char ArcNotificationContentView::kViewClassName[] =
+    "ArcNotificationContentView";
+
+// static
+ArcNotificationSurfaceManager*
+    ArcNotificationContentView::surface_manager_for_testing_ = nullptr;
+
 ArcNotificationContentView::ArcNotificationContentView(
     ArcNotificationItem* item)
     : item_(item),
       notification_key_(item->GetNotificationKey()),
       event_forwarder_(new EventForwarder(this)) {
   SetFocusBehavior(FocusBehavior::ALWAYS);
 
   item_->IncrementWindowRefCount();
   item_->AddObserver(this);
 
-  auto* surface_manager = ArcNotificationSurfaceManager::Get();
+  auto* surface_manager = GetSurfaceManager();
   if (surface_manager) {
     surface_manager->AddObserver(this);
-    exo::NotificationSurface* surface =
-        surface_manager->GetSurface(notification_key_);
+    ArcNotificationSurface* surface =
+        surface_manager->GetArcSurface(notification_key_);
     if (surface)
       OnNotificationSurfaceAdded(surface);
   }
 
   // Create a layer as an anchor to insert surface copy during a slide.
   SetPaintToLayer();
   UpdatePreferredSize();
   UpdateAccessibleName();
 }
 
 ArcNotificationContentView::~ArcNotificationContentView() {
   SetSurface(nullptr);
 
-  auto* surface_manager = ArcNotificationSurfaceManager::Get();
+  auto* surface_manager = GetSurfaceManager();
   if (surface_manager)
     surface_manager->RemoveObserver(this);
   if (item_) {
     item_->RemoveObserver(this);
     item_->DecrementWindowRefCount();
   }
 }
 
+const char* ArcNotificationContentView::GetClassName() const {
+  return kViewClassName;
+}
+
 std::unique_ptr<ArcNotificationContentViewDelegate>
 ArcNotificationContentView::CreateContentViewDelegate() {
   return base::MakeUnique<ArcNotificationContentView::ContentViewDelegate>(
       this);
 }
 
+ArcNotificationSurfaceManager* ArcNotificationContentView::GetSurfaceManager()
+    const {
+  if (surface_manager_for_testing_)
+    return surface_manager_for_testing_;
+  return ArcNotificationSurfaceManager::Get();
+}
+
 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(
@@ skipping 31 matching lines @@
       new views::BoxLayout(views::BoxLayout::kHorizontal, 0, 0, 0));
 
   if (item_->IsOpeningSettingsSupported())
     CreateSettingsButton();
   if (!item_->GetPinned())
     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();
+  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(exo::NotificationSurface* surface) {
+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_->window()) {
-    surface_->window()->RemoveObserver(this);
-    surface_->window()->RemovePreTargetHandler(event_forwarder_.get());
+  if (surface_ && surface_->GetWindow()) {
+    surface_->GetWindow()->RemoveObserver(this);
+    surface_->GetWindow()->RemovePreTargetHandler(event_forwarder_.get());
   }
 
   surface_ = surface;
 
-  if (surface_ && surface_->window()) {
-    surface_->window()->AddObserver(this);
-    surface_->window()->AddPreTargetHandler(event_forwarder_.get());
+  if (surface_ && surface_->GetWindow()) {
+    surface_->GetWindow()->AddObserver(this);
+    surface_->GetWindow()->AddPreTargetHandler(event_forwarder_.get());
 
     MaybeCreateFloatingControlButtons();
 
     if (GetWidget())
       AttachSurface();
   }
 }
 
 void ArcNotificationContentView::UpdatePreferredSize() {
   gfx::Size preferred_size;
@@ skipping 65 matching lines @@
 
   UpdatePreferredSize();
   SchedulePaint();
 }
 
 void ArcNotificationContentView::AttachSurface() {
   if (!GetWidget())
     return;
 
   UpdatePreferredSize();
-  Attach(surface_->window());
+  surface_->AttachWindow(this);
 
   // The texture for this window can be placed at subpixel position
   // with fractional scale factor. Force to align it at the pixel
   // boundary here, and when layout is updated in Layout().
-  ash::wm::SnapWindowToPixelBoundary(surface_->window());
+  ash::wm::SnapWindowToPixelBoundary(surface_->GetWindow());
 
   // 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();
 
   // Updates pinned state to create or destroy the floating close button
   // after |surface_| is attached to a widget.
   if (item_)
@@ skipping 72 matching lines @@
   const gfx::Size surface_size = surface_->GetSize();
   const gfx::Size contents_size = contents_bounds.size();
   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_->window()->children()[0]->SetTransform(transform);
+  surface_->GetWindow()->children()[0]->SetTransform(transform);
 
   if (!floating_control_buttons_widget_)
     return;
 
   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();
   }
   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_->window());
+  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.
   if (surface_ || !item_ || item_->GetSnapshot().isNull())
     return;
   const gfx::Rect contents_bounds = GetContentsBounds();
   canvas->DrawImageInt(item_->GetSnapshot(), 0, 0, item_->GetSnapshot().width(),
@@ skipping 96 matching lines @@
 
 void ArcNotificationContentView::OnItemUpdated() {
   UpdateAccessibleName();
   UpdatePinnedState();
   UpdateSnapshot();
   if (ShouldUpdateControlButtonsColor())
     StartControlButtonsColorAnimation();
 }
 
 void ArcNotificationContentView::OnNotificationSurfaceAdded(
-    exo::NotificationSurface* surface) {
-  if (surface->notification_id() != notification_key_)
+    ArcNotificationSurface* surface) {
+  if (surface->GetNotificationId() != notification_key_)
     return;
 
   SetSurface(surface);
 }
 
 void ArcNotificationContentView::OnNotificationSurfaceRemoved(
-    exo::NotificationSurface* surface) {
-  if (surface->notification_id() != notification_key_)
+    ArcNotificationSurface* surface) {
+  if (surface->GetNotificationId() != 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();
 }
@@ skipping 18 matching lines @@
     }
     if (close_button_) {
       close_button_->set_background(
           views::Background::CreateSolidBackground(current_color));
       close_button_->SchedulePaint();
     }
   }
 }
 
 }  // namespace arc