Add a unit test for the experimental app list.

ui/app_list/views/app_list_view_unittest.cc

 // Copyright 2014 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/app_list/views/app_list_view.h"
 
 #include "base/command_line.h"
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/app_list/app_list_switches.h"
 #include "ui/app_list/pagination_model.h"
 #include "ui/app_list/test/app_list_test_model.h"
 #include "ui/app_list/test/app_list_test_view_delegate.h"
 #include "ui/app_list/views/app_list_folder_view.h"
 #include "ui/app_list/views/app_list_main_view.h"
 #include "ui/app_list/views/apps_container_view.h"
 #include "ui/app_list/views/apps_grid_view.h"
 #include "ui/app_list/views/contents_view.h"
 #include "ui/app_list/views/search_box_view.h"
+#include "ui/app_list/views/start_page_view.h"
 #include "ui/app_list/views/test/apps_grid_view_test_api.h"
 #include "ui/aura/test/aura_test_base.h"
 #include "ui/aura/window.h"
 #include "ui/views/test/views_test_base.h"
 #include "ui/views/views_delegate.h"
 #include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
 
 namespace app_list {
 namespace test {
 
 namespace {
 
+enum TestType {
+  TEST_TYPE_START = 0,
+  NORMAL = TEST_TYPE_START,
+  LANDSCAPE,
+  EXPERIMENTAL,
+  TEST_TYPE_END,
+};
+
+bool IsViewAtOrigin(views::View* view) {
+  return view->bounds().origin().IsOrigin();
+}
+
 // Choose a set that is 3 regular app list pages and 2 landscape app list pages.
 const int kInitialItems = 34;
 
 // Allows the same tests to run with different contexts: either an Ash-style
 // root window or a desktop window tree host.
 class AppListViewTestContext {
  public:
-  AppListViewTestContext(bool is_landscape, aura::Window* parent);
+  AppListViewTestContext(int test_type, aura::Window* parent);
   ~AppListViewTestContext();
 
   // Test displaying the app list and performs a standard set of checks on its
   // top level views. Then closes the window.
   void RunDisplayTest();
 
   // Hides and reshows the app list with a folder open, expecting the main grid
   // view to be shown.
   void RunReshowWithOpenFolderTest();
 
+  // Tests displaying of the experimental app list and shows the start page.
+  void RunStartPageTest();
+
   // A standard set of checks on a view, e.g., ensuring it is drawn and visible.
   static void CheckView(views::View* subview);
 
   // Invoked when the Widget is closing, and the view it contains is about to
   // be torn down. This only occurs in a run loop and will be used as a signal
   // to quit.
   void NativeWidgetClosing() {
     view_ = NULL;
     run_loop_->Quit();
   }
 
   // Whether the experimental "landscape" app launcher UI is being tested.
-  bool is_landscape() const { return is_landscape_; }
+  bool is_landscape() const {
+    return test_type_ == LANDSCAPE || test_type_ == EXPERIMENTAL;
+  }
 
  private:
   // Shows the app list and waits until a paint occurs.
   void Show();
 
   // Closes the app list. This sets |view_| to NULL.
   void Close();
 
-  const bool is_landscape_;
+  const TestType test_type_;
   scoped_ptr<base::RunLoop> run_loop_;
   PaginationModel pagination_model_;
   app_list::AppListView* view_;  // Owned by native widget.
   app_list::test::AppListTestViewDelegate* delegate_;  // Owned by |view_|;
 
   DISALLOW_COPY_AND_ASSIGN(AppListViewTestContext);
 };
 
 // Extend the regular AppListTestViewDelegate to communicate back to the test
 // context. Note the test context doesn't simply inherit this, because the
 // delegate is owned by the view.
 class UnitTestViewDelegate : public app_list::test::AppListTestViewDelegate {
  public:
   UnitTestViewDelegate(AppListViewTestContext* parent) : parent_(parent) {}
 
   // Overridden from app_list::AppListViewDelegate:
   virtual bool ShouldCenterWindow() const OVERRIDE {
     return app_list::switches::IsCenteredAppListEnabled();
   }
 
   // Overridden from app_list::test::AppListTestViewDelegate:
   virtual void ViewClosing() OVERRIDE { parent_->NativeWidgetClosing(); }
 
  private:
   AppListViewTestContext* parent_;
 
   DISALLOW_COPY_AND_ASSIGN(UnitTestViewDelegate);
 };
 
-AppListViewTestContext::AppListViewTestContext(bool is_landscape,
+AppListViewTestContext::AppListViewTestContext(int test_type,
                                                aura::Window* parent)
-    : is_landscape_(is_landscape) {
-  if (is_landscape_) {
-    base::CommandLine::ForCurrentProcess()->AppendSwitch(
-        switches::kEnableCenteredAppList);
+    : test_type_(static_cast<TestType>(test_type)) {
+  switch (test_type_) {
+    case NORMAL:
+      break;
+    case LANDSCAPE:
+      base::CommandLine::ForCurrentProcess()->AppendSwitch(
+          switches::kEnableCenteredAppList);
+      break;
+    case EXPERIMENTAL:
+      base::CommandLine::ForCurrentProcess()->AppendSwitch(
+          switches::kEnableExperimentalAppList);
+      break;
+    default:
+      NOTREACHED();
+      break;
   }
 
   delegate_ = new UnitTestViewDelegate(this);
   view_ = new app_list::AppListView(delegate_);
 
   // Initialize centered around a point that ensures the window is wholly shown.
   view_->InitAsBubbleAtFixedLocation(parent,
                                      &pagination_model_,
                                      gfx::Point(300, 300),
                                      views::BubbleBorder::FLOAT,
@@ skipping 32 matching lines @@
   // |view_| should have been deleted and set to NULL via ViewClosing().
   EXPECT_FALSE(view_);
 }
 
 void AppListViewTestContext::RunDisplayTest() {
   EXPECT_FALSE(view_->GetWidget()->IsVisible());
   EXPECT_EQ(-1, pagination_model_.total_pages());
   delegate_->GetTestModel()->PopulateApps(kInitialItems);
 
   Show();
-  if (is_landscape_)
+  if (is_landscape())
     EXPECT_EQ(2, pagination_model_.total_pages());
   else
     EXPECT_EQ(3, pagination_model_.total_pages());
   EXPECT_EQ(0, pagination_model_.selected_page());
 
   // Checks on the main view.
   AppListMainView* main_view = view_->app_list_main_view();
   EXPECT_NO_FATAL_FAILURE(CheckView(main_view));
   EXPECT_NO_FATAL_FAILURE(CheckView(main_view->search_box_view()));
   EXPECT_NO_FATAL_FAILURE(CheckView(main_view->contents_view()));
@@ skipping 38 matching lines @@
   Show();
 
   // The main grid view should be showing after a reshow.
   EXPECT_NO_FATAL_FAILURE(CheckView(main_view));
   EXPECT_NO_FATAL_FAILURE(CheckView(container_view->apps_grid_view()));
   EXPECT_FALSE(container_view->app_list_folder_view()->visible());
 
   Close();
 }
 
+void AppListViewTestContext::RunStartPageTest() {
+  EXPECT_FALSE(view_->GetWidget()->IsVisible());
+  EXPECT_EQ(-1, pagination_model_.total_pages());
+  delegate_->GetTestModel()->PopulateApps(kInitialItems);
+
+  Show();
+
+  AppListMainView* main_view = view_->app_list_main_view();
+  StartPageView* start_page_view =
+      main_view->contents_view()->start_page_view();
+  // Checks on the main view.
+  EXPECT_NO_FATAL_FAILURE(CheckView(main_view));
+  EXPECT_NO_FATAL_FAILURE(CheckView(main_view->contents_view()));
+  if (test_type_ == EXPERIMENTAL) {
+    EXPECT_NO_FATAL_FAILURE(CheckView(start_page_view));
+
+    main_view->contents_view()->SetShowState(ContentsView::SHOW_START_PAGE);
+    main_view->contents_view()->Layout();
+    EXPECT_FALSE(main_view->search_box_view()->visible());
+    EXPECT_TRUE(IsViewAtOrigin(start_page_view));
+    EXPECT_FALSE(
+        IsViewAtOrigin(main_view->contents_view()->apps_container_view()));
+
+    main_view->contents_view()->SetShowState(ContentsView::SHOW_APPS);
+    main_view->contents_view()->Layout();
+    EXPECT_TRUE(main_view->search_box_view()->visible());
+    EXPECT_FALSE(IsViewAtOrigin(start_page_view));
+    EXPECT_TRUE(
+        IsViewAtOrigin(main_view->contents_view()->apps_container_view()));
+  } else {
+    EXPECT_EQ(NULL, start_page_view);
+  }
+
+  Close();
+}
+
 class AppListViewTestAura : public views::ViewsTestBase,
-                            public ::testing::WithParamInterface<bool> {
+                            public ::testing::WithParamInterface<int> {
  public:
   AppListViewTestAura() {}
   virtual ~AppListViewTestAura() {}
 
   // testing::Test overrides:
   virtual void SetUp() OVERRIDE {
     views::ViewsTestBase::SetUp();
     test_context_.reset(new AppListViewTestContext(GetParam(), GetContext()));
   }
 
   virtual void TearDown() OVERRIDE {
     test_context_.reset();
     views::ViewsTestBase::TearDown();
   }
 
  protected:
   scoped_ptr<AppListViewTestContext> test_context_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AppListViewTestAura);
 };
 
 class AppListViewTestDesktop : public views::ViewsTestBase,
-                               public ::testing::WithParamInterface<bool> {
+                               public ::testing::WithParamInterface<int> {
  public:
   AppListViewTestDesktop() {}
   virtual ~AppListViewTestDesktop() {}
 
   // testing::Test overrides:
   virtual void SetUp() OVERRIDE {
     set_views_delegate(new AppListViewTestViewsDelegate(this));
     views::ViewsTestBase::SetUp();
     test_context_.reset(new AppListViewTestContext(GetParam(), NULL));
   }
@@ skipping 58 matching lines @@
 // Tests that the main grid view is shown after hiding and reshowing the app
 // list with a folder view open. This is a regression test for crbug.com/357058.
 TEST_P(AppListViewTestAura, ReshowWithOpenFolder) {
   EXPECT_NO_FATAL_FAILURE(test_context_->RunReshowWithOpenFolderTest());
 }
 
 TEST_P(AppListViewTestDesktop, ReshowWithOpenFolder) {
   EXPECT_NO_FATAL_FAILURE(test_context_->RunReshowWithOpenFolderTest());
 }
 
+// Tests that the start page view operates correctly.
+TEST_P(AppListViewTestAura, StartPageTest) {
+  EXPECT_NO_FATAL_FAILURE(test_context_->RunStartPageTest());
+}
+
+TEST_P(AppListViewTestDesktop, StartPageTest) {
+  EXPECT_NO_FATAL_FAILURE(test_context_->RunStartPageTest());
+}
+
 INSTANTIATE_TEST_CASE_P(AppListViewTestAuraInstance,
                         AppListViewTestAura,
-                        ::testing::Bool());
+                        ::testing::Range<int>(TEST_TYPE_START, TEST_TYPE_END));
 
 INSTANTIATE_TEST_CASE_P(AppListViewTestDesktopInstance,
                         AppListViewTestDesktop,
-                        ::testing::Bool());
+                        ::testing::Range<int>(TEST_TYPE_START, TEST_TYPE_END));
 
 }  // namespace test
 }  // namespace app_list