Move message_center::CustomNotificationView to arc::ArcNotificationView

ui/arc/notification/arc_notification_view_unittest.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 <memory>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/utf_string_conversions.h"
 #include "third_party/skia/include/core/SkColor.h"
+#include "ui/arc/notification/arc_notification_content_view_delegate.h"
+#include "ui/arc/notification/arc_notification_view.h"
 #include "ui/base/ime/dummy_text_input_client.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/base/ime/text_input_client.h"
 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/test/event_generator.h"
 #include "ui/message_center/notification.h"
 #include "ui/message_center/notification_delegate.h"
-#include "ui/message_center/views/custom_notification_view.h"
 #include "ui/message_center/views/message_center_controller.h"
 #include "ui/message_center/views/message_view_factory.h"
 #include "ui/views/background.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/test/views_test_base.h"
 
-namespace message_center {
+namespace arc {
 
 namespace {
 
 const SkColor kBackgroundColor = SK_ColorGREEN;
 
-class TestCustomView : public views::View {
+class TestNotificationContentsView : public views::View {
  public:
-  TestCustomView() {
+  TestNotificationContentsView() {
     SetFocusBehavior(FocusBehavior::ALWAYS);
     set_background(views::Background::CreateSolidBackground(kBackgroundColor));
     set_preferred_size(gfx::Size(100, 100));
   }
-  ~TestCustomView() override {}
+  ~TestNotificationContentsView() override = default;
 
   void Reset() {
     mouse_event_count_ = 0;
     keyboard_event_count_ = 0;
   }
 
   // views::View
   bool OnMousePressed(const ui::MouseEvent& event) override {
     ++mouse_event_count_;
     return true;
   }
   void OnMouseMoved(const ui::MouseEvent& event) override {
     ++mouse_event_count_;
   }
   void OnMouseReleased(const ui::MouseEvent& event) override {
     ++mouse_event_count_;
   }
   bool OnKeyPressed(const ui::KeyEvent& event) override {
     ++keyboard_event_count_;
     return false;
   }
 
   int mouse_event_count() const { return mouse_event_count_; }
   int keyboard_event_count() const { return keyboard_event_count_; }
 
  private:
   int mouse_event_count_ = 0;
   int keyboard_event_count_ = 0;
 
-  DISALLOW_COPY_AND_ASSIGN(TestCustomView);
+  DISALLOW_COPY_AND_ASSIGN(TestNotificationContentsView);
 };
 
-class TestContentViewDelegate : public CustomNotificationContentViewDelegate {
+class TestContentViewDelegate : public ArcNotificationContentViewDelegate {
  public:
   bool IsCloseButtonFocused() const override { return false; }
   void RequestFocusOnCloseButton() override {}
   void UpdateControlButtonsVisibility() override {}
   void OnSlideChanged() override {}
 };
 
-class TestNotificationDelegate : public NotificationDelegate {
+class TestNotificationDelegate : public message_center::NotificationDelegate {
  public:
-  TestNotificationDelegate() {}
+  TestNotificationDelegate() = default;
 
   // NotificateDelegate
-  std::unique_ptr<CustomContent> CreateCustomContent() override {
-    return base::MakeUnique<CustomContent>(
-        base::MakeUnique<TestCustomView>(),
-        base::MakeUnique<TestContentViewDelegate>());
+  std::unique_ptr<message_center::MessageView> CreateCustomMessageView(
+      message_center::MessageCenterController* controller,
+      const message_center::Notification& notification) override {
+    return base::MakeUnique<ArcNotificationView>(
+        base::MakeUnique<TestNotificationContentsView>(),
+        base::MakeUnique<TestContentViewDelegate>(), controller, notification);
   }
 
  private:
-  ~TestNotificationDelegate() override {}
+  ~TestNotificationDelegate() override = default;
 
   DISALLOW_COPY_AND_ASSIGN(TestNotificationDelegate);
 };
 
-class TestMessageCenterController : public MessageCenterController {
+class TestMessageCenterController
+    : public message_center::MessageCenterController {
  public:
-  TestMessageCenterController() {}
+  TestMessageCenterController() = default;
 
   // MessageCenterController
   void ClickOnNotification(const std::string& notification_id) override {
     // For this test, this method should not be invoked.
     NOTREACHED();
   }
 
   void RemoveNotification(const std::string& notification_id,
                           bool by_user) override {
     removed_ids_.insert(notification_id);
   }
 
   std::unique_ptr<ui::MenuModel> CreateMenuModel(
-      const NotifierId& notifier_id,
+      const message_center::NotifierId& notifier_id,
       const base::string16& display_source) override {
     // For this test, this method should not be invoked.
     NOTREACHED();
     return nullptr;
   }
 
   bool HasClickedListener(const std::string& notification_id) override {
     return false;
   }
 
@@ skipping 32 matching lines @@
   void set_text_input_type(ui::TextInputType type) { type_ = type; }
 
  private:
   ui::TextInputType type_ = ui::TEXT_INPUT_TYPE_NONE;
 
   DISALLOW_COPY_AND_ASSIGN(TestTextInputClient);
 };
 
 }  // namespace
 
-class CustomNotificationViewTest : public views::ViewsTestBase {
+class ArcNotificationViewTest : public views::ViewsTestBase {
  public:
-  CustomNotificationViewTest() {}
-  ~CustomNotificationViewTest() override {}
+  ArcNotificationViewTest() = default;
+  ~ArcNotificationViewTest() override = default;
 
   // views::ViewsTestBase
   void SetUp() override {
     views::ViewsTestBase::SetUp();
 
     notification_delegate_ = new TestNotificationDelegate;
 
-    notification_.reset(new Notification(
-        NOTIFICATION_TYPE_CUSTOM, std::string("notification id"),
-        base::UTF8ToUTF16("title"), base::UTF8ToUTF16("message"), gfx::Image(),
+    notification_ = base::MakeUnique<message_center::Notification>(
+        message_center::NOTIFICATION_TYPE_CUSTOM,
+        std::string("notification id"), base::UTF8ToUTF16("title"),
+        base::UTF8ToUTF16("message"), gfx::Image(),
         base::UTF8ToUTF16("display source"), GURL(),
-        NotifierId(NotifierId::APPLICATION, "extension_id"),
-        message_center::RichNotificationData(), notification_delegate_.get()));
+        message_center::NotifierId(message_center::NotifierId::APPLICATION,
+                                   "extension_id"),
+        message_center::RichNotificationData(), notification_delegate_.get());
 
-    notification_view_.reset(static_cast<CustomNotificationView*>(
-        MessageViewFactory::Create(controller(), *notification_, true)));
+    notification_view_.reset(static_cast<ArcNotificationView*>(
+        message_center::MessageViewFactory::Create(controller(), *notification_,
+                                                   true)));
     notification_view_->set_owned_by_client();
 
     views::Widget::InitParams init_params(
         CreateParams(views::Widget::InitParams::TYPE_POPUP));
     views::Widget* widget = new views::Widget();
     widget->Init(init_params);
     widget->SetContentsView(notification_view_.get());
     widget->SetSize(notification_view_->GetPreferredSize());
     widget->Show();
   }
@@ skipping 56 matching lines @@
   void EndScroll() {
     DispatchGesture(ui::GestureEventDetails(ui::ET_GESTURE_SCROLL_END));
   }
 
   void ScrollBy(int dx) {
     DispatchGesture(
         ui::GestureEventDetails(ui::ET_GESTURE_SCROLL_UPDATE, dx, 0));
   }
 
   TestMessageCenterController* controller() { return &controller_; }
-  Notification* notification() { return notification_.get(); }
-  TestCustomView* custom_view() {
-    return static_cast<TestCustomView*>(notification_view_->contents_view_);
+  message_center::Notification* notification() { return notification_.get(); }
+  TestNotificationContentsView* contents_view() {
+    return static_cast<TestNotificationContentsView*>(
+        notification_view_->contents_view_);
   }
   views::Widget* widget() { return notification_view_->GetWidget(); }
-  CustomNotificationView* notification_view() {
-    return notification_view_.get();
-  }
+  ArcNotificationView* notification_view() { return notification_view_.get(); }
 
  private:
   TestMessageCenterController controller_;
   scoped_refptr<TestNotificationDelegate> notification_delegate_;
-  std::unique_ptr<Notification> notification_;
-  std::unique_ptr<CustomNotificationView> notification_view_;
+  std::unique_ptr<message_center::Notification> notification_;
+  std::unique_ptr<ArcNotificationView> notification_view_;
 
-  DISALLOW_COPY_AND_ASSIGN(CustomNotificationViewTest);
+  DISALLOW_COPY_AND_ASSIGN(ArcNotificationViewTest);
 };
 
-TEST_F(CustomNotificationViewTest, Background) {
+TEST_F(ArcNotificationViewTest, Background) {
   EXPECT_EQ(kBackgroundColor, GetBackgroundColor());
 }
 
-TEST_F(CustomNotificationViewTest, Events) {
+TEST_F(ArcNotificationViewTest, Events) {
   widget()->Show();
-  custom_view()->RequestFocus();
+  contents_view()->RequestFocus();
 
-  EXPECT_EQ(0, custom_view()->mouse_event_count());
+  EXPECT_EQ(0, contents_view()->mouse_event_count());
   gfx::Point cursor_location(1, 1);
-  views::View::ConvertPointToWidget(custom_view(), &cursor_location);
+  views::View::ConvertPointToWidget(contents_view(), &cursor_location);
   PerformClick(cursor_location);
-  EXPECT_EQ(2, custom_view()->mouse_event_count());
+  EXPECT_EQ(2, contents_view()->mouse_event_count());
 
   ui::MouseEvent move(ui::ET_MOUSE_MOVED, cursor_location, cursor_location,
                       ui::EventTimeForNow(), ui::EF_NONE, ui::EF_NONE);
   widget()->OnMouseEvent(&move);
-  EXPECT_EQ(3, custom_view()->mouse_event_count());
+  EXPECT_EQ(3, contents_view()->mouse_event_count());
 
-  EXPECT_EQ(0, custom_view()->keyboard_event_count());
+  EXPECT_EQ(0, contents_view()->keyboard_event_count());
   KeyPress(ui::VKEY_A);
-  EXPECT_EQ(1, custom_view()->keyboard_event_count());
+  EXPECT_EQ(1, contents_view()->keyboard_event_count());
 }
 
-TEST_F(CustomNotificationViewTest, SlideOut) {
+TEST_F(ArcNotificationViewTest, SlideOut) {
   ui::ScopedAnimationDurationScaleMode zero_duration_scope(
       ui::ScopedAnimationDurationScaleMode::ZERO_DURATION);
 
   UpdateNotificationViews();
   std::string notification_id = notification()->id();
 
   BeginScroll();
   ScrollBy(-10);
   EXPECT_FALSE(controller()->IsRemoved(notification_id));
   EXPECT_EQ(-10.f, GetNotificationSlideAmount());
   EndScroll();
   EXPECT_FALSE(controller()->IsRemoved(notification_id));
   EXPECT_EQ(0.f, GetNotificationSlideAmount());
 
   BeginScroll();
   ScrollBy(-200);
   EXPECT_FALSE(controller()->IsRemoved(notification_id));
   EXPECT_EQ(-200.f, GetNotificationSlideAmount());
   EndScroll();
   EXPECT_TRUE(controller()->IsRemoved(notification_id));
 }
 
-TEST_F(CustomNotificationViewTest, SlideOutNested) {
+TEST_F(ArcNotificationViewTest, SlideOutNested) {
   ui::ScopedAnimationDurationScaleMode zero_duration_scope(
       ui::ScopedAnimationDurationScaleMode::ZERO_DURATION);
 
   UpdateNotificationViews();
   notification_view()->SetIsNested();
   std::string notification_id = notification()->id();
 
   BeginScroll();
   ScrollBy(-10);
   EXPECT_FALSE(controller()->IsRemoved(notification_id));
   EXPECT_EQ(-10.f, GetNotificationSlideAmount());
   EndScroll();
   EXPECT_FALSE(controller()->IsRemoved(notification_id));
   EXPECT_EQ(0.f, GetNotificationSlideAmount());
 
   BeginScroll();
   ScrollBy(-200);
   EXPECT_FALSE(controller()->IsRemoved(notification_id));
   EXPECT_EQ(-200.f, GetNotificationSlideAmount());
   EndScroll();
   EXPECT_TRUE(controller()->IsRemoved(notification_id));
 }
 
 // Pinning notification is ChromeOS only feature.
 #if defined(OS_CHROMEOS)
 
-TEST_F(CustomNotificationViewTest, SlideOutPinned) {
+TEST_F(ArcNotificationViewTest, SlideOutPinned) {
   ui::ScopedAnimationDurationScaleMode zero_duration_scope(
       ui::ScopedAnimationDurationScaleMode::ZERO_DURATION);
 
   notification()->set_pinned(true);
   UpdateNotificationViews();
   std::string notification_id = notification()->id();
 
   BeginScroll();
   ScrollBy(-200);
   EXPECT_FALSE(controller()->IsRemoved(notification_id));
   EXPECT_LT(-200.f, GetNotificationSlideAmount());
   EndScroll();
   EXPECT_FALSE(controller()->IsRemoved(notification_id));
 }
 
 #endif  // defined(OS_CHROMEOS)
 
-TEST_F(CustomNotificationViewTest, PressBackspaceKey) {
+TEST_F(ArcNotificationViewTest, PressBackspaceKey) {
   std::string notification_id = notification()->id();
-  custom_view()->RequestFocus();
+  contents_view()->RequestFocus();
 
-  ui::InputMethod* input_method = custom_view()->GetInputMethod();
+  ui::InputMethod* input_method = contents_view()->GetInputMethod();
   ASSERT_TRUE(input_method);
   TestTextInputClient text_input_client;
   input_method->SetFocusedTextInputClient(&text_input_client);
   ASSERT_EQ(&text_input_client, input_method->GetTextInputClient());
 
   EXPECT_FALSE(controller()->IsRemoved(notification_id));
   PerformKeyEvents(ui::VKEY_BACK);
   EXPECT_TRUE(controller()->IsRemoved(notification_id));
 
   input_method->SetFocusedTextInputClient(nullptr);
 }
 
-TEST_F(CustomNotificationViewTest, PressBackspaceKeyOnEditBox) {
+TEST_F(ArcNotificationViewTest, PressBackspaceKeyOnEditBox) {
   std::string notification_id = notification()->id();
-  custom_view()->RequestFocus();
+  contents_view()->RequestFocus();
 
-  ui::InputMethod* input_method = custom_view()->GetInputMethod();
+  ui::InputMethod* input_method = contents_view()->GetInputMethod();
   ASSERT_TRUE(input_method);
   TestTextInputClient text_input_client;
   input_method->SetFocusedTextInputClient(&text_input_client);
   ASSERT_EQ(&text_input_client, input_method->GetTextInputClient());
 
   text_input_client.set_text_input_type(ui::TEXT_INPUT_TYPE_TEXT);
 
   EXPECT_FALSE(controller()->IsRemoved(notification_id));
   PerformKeyEvents(ui::VKEY_BACK);
   EXPECT_FALSE(controller()->IsRemoved(notification_id));
 
   input_method->SetFocusedTextInputClient(nullptr);
 }
 
-TEST_F(CustomNotificationViewTest, ChangeContentHeight) {
+TEST_F(ArcNotificationViewTest, ChangeContentHeight) {
   // Default size.
   gfx::Size size = notification_view()->GetPreferredSize();
   size.Enlarge(0, -notification_view()->GetInsets().height());
   EXPECT_EQ("360x100", size.ToString());
 
   // Allow small notifications.
-  custom_view()->set_preferred_size(gfx::Size(10, 10));
+  contents_view()->set_preferred_size(gfx::Size(10, 10));
   size = notification_view()->GetPreferredSize();
   size.Enlarge(0, -notification_view()->GetInsets().height());
   EXPECT_EQ("360x10", size.ToString());
 
   // The long notification.
-  custom_view()->set_preferred_size(gfx::Size(1000, 1000));
+  contents_view()->set_preferred_size(gfx::Size(1000, 1000));
   size = notification_view()->GetPreferredSize();
   size.Enlarge(0, -notification_view()->GetInsets().height());
   EXPECT_EQ("360x1000", size.ToString());
 }
 
-}  // namespace message_center
+}  // namespace arc