Add a unit test for resetting the app list on a reshow.

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/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 {
 
 // 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();
 
   // 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();
+
   // 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_; }
 
  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_;
   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
@@ skipping 44 matching lines @@
 }
 
 // static
 void AppListViewTestContext::CheckView(views::View* subview) {
   ASSERT_TRUE(subview);
   EXPECT_TRUE(subview->parent());
   EXPECT_TRUE(subview->visible());
   EXPECT_TRUE(subview->IsDrawn());
 }
 
+void AppListViewTestContext::Show() {
+  view_->GetWidget()->Show();
+  run_loop_.reset(new base::RunLoop);
+  view_->SetNextPaintCallback(run_loop_->QuitClosure());
+  run_loop_->Run();
+
+  EXPECT_TRUE(view_->GetWidget()->IsVisible());
+}
+
+void AppListViewTestContext::Close() {
+  view_->GetWidget()->Close();
+  run_loop_.reset(new base::RunLoop);
+  run_loop_->Run();
+
+  // |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());
-  view_->GetWidget()->Show();
   delegate_->GetTestModel()->PopulateApps(kInitialItems);
 
-  run_loop_.reset(new base::RunLoop);
-  view_->SetNextPaintCallback(run_loop_->QuitClosure());
-  run_loop_->Run();
-
-  EXPECT_TRUE(view_->GetWidget()->IsVisible());
-
+  Show();
   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()));
 
-  view_->GetWidget()->Close();
-  run_loop_.reset(new base::RunLoop);
-  run_loop_->Run();
+  Close();
+}
 
-  // |view_| should have been deleted and set to NULL via ViewClosing().
-  EXPECT_FALSE(view_);
+void AppListViewTestContext::RunReshowWithOpenFolderTest() {
+  EXPECT_FALSE(view_->GetWidget()->IsVisible());
+  EXPECT_EQ(-1, pagination_model_.total_pages());
+
+  AppListTestModel* model = delegate_->GetTestModel();
+  model->PopulateApps(kInitialItems);
+  const std::string folder_id =
+      model->MergeItems(model->top_level_item_list()->item_at(0)->id(),
+                        model->top_level_item_list()->item_at(1)->id());
+
+  AppListFolderItem* folder_item = model->FindFolderItem(folder_id);
+  EXPECT_TRUE(folder_item);
+
+  Show();
+
+  // The main grid view should be showing initially.
+  AppListMainView* main_view = view_->app_list_main_view();
+  AppsContainerView* container_view =
+      main_view->contents_view()->apps_container_view();
+  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());
+
+  AppsGridViewTestApi test_api(container_view->apps_grid_view());
+  test_api.PressItemAt(0);
+
+  // After pressing the folder item, the folder view should be showing.
+  EXPECT_NO_FATAL_FAILURE(CheckView(main_view));
+  EXPECT_NO_FATAL_FAILURE(CheckView(container_view->app_list_folder_view()));
+  EXPECT_FALSE(container_view->apps_grid_view()->visible());
+
+  view_->GetWidget()->Hide();
+  EXPECT_FALSE(view_->GetWidget()->IsVisible());
+
+  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();
 }
 
 class AppListViewTestAura : public views::ViewsTestBase,
                             public ::testing::WithParamInterface<bool> {
  public:
   AppListViewTestAura() {}
   virtual ~AppListViewTestAura() {}
 
   // testing::Test overrides:
   virtual void SetUp() OVERRIDE {
@@ skipping 76 matching lines @@
 TEST_P(AppListViewTestAura, Display) {
   EXPECT_NO_FATAL_FAILURE(test_context_->RunDisplayTest());
 }
 
 // Tests showing the app list on the desktop. Note on ChromeOS, this will still
 // use the regular root window.
 TEST_P(AppListViewTestDesktop, Display) {
   EXPECT_NO_FATAL_FAILURE(test_context_->RunDisplayTest());
 }
 
+// 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());
+}
+
 INSTANTIATE_TEST_CASE_P(AppListViewTestAuraInstance,

[tapted, 2014/05/22 01:21:10]

You'll need lines like these for any `TEST_P` test

[tapted, 2014/05/22 01:27:43]

oops - you're right. This TEST_P stuff is more useful than I thought.

                         AppListViewTestAura,
                         ::testing::Bool());
 
 INSTANTIATE_TEST_CASE_P(AppListViewTestDesktopInstance,
                         AppListViewTestDesktop,
                         ::testing::Bool());
 
 }  // namespace test
 }  // namespace app_list