arc: Fix Arc app item context menu.

chrome/browser/ui/app_list/app_context_menu_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 <map>
 #include <memory>
 #include <string>
 #include <unordered_set>
 #include <vector>
 
 #include "base/macros.h"
 
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/extensions/menu_manager_factory.h"
 #include "chrome/browser/ui/app_list/app_context_menu_delegate.h"
 #include "chrome/browser/ui/app_list/app_list_controller_delegate.h"
 #include "chrome/browser/ui/app_list/app_list_test_util.h"
 #include "chrome/browser/ui/app_list/chrome_app_list_item.h"
 #include "chrome/browser/ui/app_list/extension_app_context_menu.h"
 #include "chrome/browser/ui/app_list/test/test_app_list_controller_delegate.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/ui/app_list/arc/arc_app_item.h"
+#include "chrome/browser/ui/app_list/arc/arc_app_list_prefs.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_test.h"
 #include "components/arc/test/fake_app_instance.h"
 #include "components/arc/test/fake_arc_bridge_service.h"
 #endif
 
 namespace {
 
 class FakeAppContextMenuDelegate : public app_list::AppContextMenuDelegate {
  public:
   FakeAppContextMenuDelegate() = default;
@@ skipping 105 matching lines @@
         : command_id(command_id),
           is_enabled(enabled),
           is_checked(checked) {
     }
 
     int command_id;
     bool is_enabled;
     bool is_checked;
   };
 
+  void ValidateItemState(const ui::MenuModel* menu_model,
+                         int index,
+                         const MenuState& state) {
+    EXPECT_EQ(state.command_id, menu_model->GetCommandIdAt(index));
+    if (state.command_id == -1)
+      return;   // Don't check separator.
+    EXPECT_EQ(state.is_enabled, menu_model->IsEnabledAt(index));
+    EXPECT_EQ(state.is_checked, menu_model->IsItemCheckedAt(index));
+  }
+
   void ValidateMenuState(const ui::MenuModel* menu_model,
                          const std::vector<MenuState>& states) {
     ASSERT_NE(nullptr, menu_model);
     size_t state_index = 0;
     for (int i = 0; i < menu_model->GetItemCount(); ++i) {
       ASSERT_LT(state_index, states.size());
-      const MenuState& state = states[state_index++];
-      EXPECT_EQ(state.command_id, menu_model->GetCommandIdAt(i));
-      if (state.command_id == -1)
-        continue;   // Don't check separator.
-      EXPECT_EQ(state.is_enabled, menu_model->IsEnabledAt(i));
-      EXPECT_EQ(state.is_checked, menu_model->IsItemCheckedAt(i));
+      ValidateItemState(menu_model, i, states[state_index++]);
     }
     EXPECT_EQ(state_index, states.size());
   }
 
   FakeAppListControllerDelegate* controller() {
     return controller_.get();
   }
 
   FakeAppContextMenuDelegate* menu_delegate() {
     return menu_delegate_.get();
@@ skipping 167 matching lines @@
                                          controller());
   ui::MenuModel* menu_model = menu.GetMenuModel();
   EXPECT_EQ(nullptr, menu_model);
 }
 
 #if defined(OS_CHROMEOS)
 TEST_F(AppContextMenuTest, ArcMenu) {
   ArcAppTest arc_test;
   arc_test.SetUp(profile());
 
-  const arc::mojom::AppInfo& app_info = arc_test.fake_apps()[0];
+  const arc::mojom::AppInfo& app_info = arc_test.fake_apps()[1];

[khmel, 2016/10/03 23:48:03]

0 app is sticky and does not have uninstall item. We have one more test case for
this bellow. It is beneficial to test normal case here.

   const std::string app_id = ArcAppTest::GetAppId(app_info);
   controller()->SetAppPinnable(app_id, AppListControllerDelegate::PIN_EDITABLE);
 
   arc_test.app_instance()->RefreshAppList();
   arc_test.app_instance()->SendRefreshAppList(arc_test.fake_apps());
 
   ArcAppItem item(profile(), nullptr, app_id, std::string());
 
   ui::MenuModel* menu = item.GetContextMenuModel();
   ASSERT_NE(nullptr, menu);
 
-  ASSERT_EQ(4, menu->GetItemCount());
-  EXPECT_EQ(app_list::AppContextMenu::LAUNCH_NEW, menu->GetCommandIdAt(0));
-  EXPECT_TRUE(menu->IsEnabledAt(0));
-  EXPECT_FALSE(menu->IsItemCheckedAt(0));
-  EXPECT_EQ(-1, menu->GetCommandIdAt(1));  // separator
-  EXPECT_EQ(app_list::AppContextMenu::TOGGLE_PIN, menu->GetCommandIdAt(2));
-  EXPECT_TRUE(menu->IsEnabledAt(2));
-  EXPECT_FALSE(menu->IsItemCheckedAt(2));
-  EXPECT_EQ(app_list::AppContextMenu::SHOW_APP_INFO, menu->GetCommandIdAt(3));
-  EXPECT_TRUE(menu->IsEnabledAt(3));
-  EXPECT_FALSE(menu->IsItemCheckedAt(3));
+  ASSERT_EQ(6, menu->GetItemCount());
+  ValidateItemState(menu, 0, MenuState(app_list::AppContextMenu::LAUNCH_NEW));
+  ValidateItemState(menu, 1, MenuState());  // separator
+  ValidateItemState(menu, 2, MenuState(app_list::AppContextMenu::TOGGLE_PIN));
+  ValidateItemState(menu, 3, MenuState());  // separator
+  ValidateItemState(menu, 4, MenuState(app_list::AppContextMenu::UNINSTALL));
+  ValidateItemState(
+      menu, 5, MenuState(app_list::AppContextMenu::SHOW_APP_INFO));
 
   // Test activate request.
   EXPECT_EQ(0u, arc_test.app_instance()->launch_requests().size());
 
   menu->ActivatedAt(0);
 
   const std::vector<std::unique_ptr<arc::FakeAppInstance::Request>>&
       launch_requests = arc_test.app_instance()->launch_requests();
   ASSERT_EQ(1u, launch_requests.size());
   EXPECT_TRUE(launch_requests[0]->IsForApp(app_info));
 
   controller()->SetAppOpen(app_id, true);
   // It is not expected that menu model is unchanged on GetContextMenuModel. Arc
   // app menu requires model to be recalculated.
   menu = item.GetContextMenuModel();
-  ASSERT_EQ(2, menu->GetItemCount());
-  EXPECT_EQ(app_list::AppContextMenu::TOGGLE_PIN, menu->GetCommandIdAt(0));
-  EXPECT_TRUE(menu->IsEnabledAt(0));
-  EXPECT_FALSE(menu->IsItemCheckedAt(0));
-  EXPECT_EQ(app_list::AppContextMenu::SHOW_APP_INFO, menu->GetCommandIdAt(1));
-  EXPECT_TRUE(menu->IsEnabledAt(1));
-  EXPECT_FALSE(menu->IsItemCheckedAt(1));
+  ASSERT_EQ(4, menu->GetItemCount());
+  ValidateItemState(menu, 0, MenuState(app_list::AppContextMenu::TOGGLE_PIN));
+  ValidateItemState(menu, 1, MenuState());  // separator
+  ValidateItemState(menu, 2, MenuState(app_list::AppContextMenu::UNINSTALL));
+  ValidateItemState(
+      menu, 3, MenuState(app_list::AppContextMenu::SHOW_APP_INFO));
 
+  // This makes all apps non-ready.
+  controller()->SetAppOpen(app_id, false);
+  arc::InstanceHolder<arc::mojom::AppInstance>::Observer* instance_observer =
+      arc_test.arc_app_list_prefs();
+  instance_observer->OnInstanceClosed();
+
+  menu = item.GetContextMenuModel();
+  ASSERT_EQ(6, menu->GetItemCount());
+  ValidateItemState(menu, 0, MenuState(app_list::AppContextMenu::LAUNCH_NEW));
+  ValidateItemState(menu, 1, MenuState());  // separator
+  ValidateItemState(menu, 2, MenuState(app_list::AppContextMenu::TOGGLE_PIN));
+  ValidateItemState(menu, 3, MenuState());  // separator
+  ValidateItemState(
+      menu, 4, MenuState(app_list::AppContextMenu::UNINSTALL, false, false));
+  ValidateItemState(
+      menu, 5,
+      MenuState(app_list::AppContextMenu::SHOW_APP_INFO, false, false));
+
+  // Uninstall all apps.
   arc_test.app_instance()->RefreshAppList();
   arc_test.app_instance()->SendRefreshAppList(
       std::vector<arc::mojom::AppInfo>());
   controller()->SetAppOpen(app_id, false);
 
+  // No app available case.
   menu = item.GetContextMenuModel();
-  ASSERT_EQ(4, menu->GetItemCount());
-  EXPECT_EQ(app_list::AppContextMenu::LAUNCH_NEW, menu->GetCommandIdAt(0));
-  EXPECT_TRUE(menu->IsEnabledAt(0));
-  EXPECT_FALSE(menu->IsItemCheckedAt(0));
-  EXPECT_EQ(-1, menu->GetCommandIdAt(1));  // separator
-  EXPECT_EQ(app_list::AppContextMenu::TOGGLE_PIN, menu->GetCommandIdAt(2));
-  EXPECT_TRUE(menu->IsEnabledAt(2));
-  EXPECT_FALSE(menu->IsItemCheckedAt(2));
-  EXPECT_EQ(app_list::AppContextMenu::SHOW_APP_INFO, menu->GetCommandIdAt(3));
-  EXPECT_TRUE(menu->IsEnabledAt(3));
-  EXPECT_FALSE(menu->IsItemCheckedAt(3));
+  EXPECT_EQ(0, menu->GetItemCount());
+}
+
+
+TEST_F(AppContextMenuTest, ArcMenuShortcut) {
+  ArcAppTest arc_test;
+  arc_test.SetUp(profile());
+
+  const arc::mojom::ShortcutInfo& shortcut_info = arc_test.fake_shortcuts()[0];
+  const std::string app_id = ArcAppTest::GetAppId(shortcut_info);
+  controller()->SetAppPinnable(app_id, AppListControllerDelegate::PIN_EDITABLE);
+
+  arc_test.app_instance()->SendInstallShortcuts(arc_test.fake_shortcuts());
+
+  ArcAppItem item(profile(), nullptr, app_id, std::string());
+
+  ui::MenuModel* menu = item.GetContextMenuModel();
+  ASSERT_NE(nullptr, menu);
+
+  ASSERT_EQ(6, menu->GetItemCount());
+  ValidateItemState(menu, 0, MenuState(app_list::AppContextMenu::LAUNCH_NEW));
+  ValidateItemState(menu, 1, MenuState());  // separator
+  ValidateItemState(menu, 2, MenuState(app_list::AppContextMenu::TOGGLE_PIN));
+  ValidateItemState(menu, 3, MenuState());  // separator
+  ValidateItemState(menu, 4, MenuState(app_list::AppContextMenu::UNINSTALL));
+  ValidateItemState(
+      menu, 5, MenuState(app_list::AppContextMenu::SHOW_APP_INFO));
+
+  // This makes all apps non-ready. Shortcut is still uninstall-able.
+  arc::InstanceHolder<arc::mojom::AppInstance>::Observer* instance_observer =
+      arc_test.arc_app_list_prefs();
+  instance_observer->OnInstanceClosed();
+
+  menu = item.GetContextMenuModel();
+  ASSERT_EQ(6, menu->GetItemCount());
+  ValidateItemState(menu, 0, MenuState(app_list::AppContextMenu::LAUNCH_NEW));
+  ValidateItemState(menu, 1, MenuState());  // separator
+  ValidateItemState(menu, 2, MenuState(app_list::AppContextMenu::TOGGLE_PIN));
+  ValidateItemState(menu, 3, MenuState());  // separator
+  ValidateItemState(menu, 4, MenuState(app_list::AppContextMenu::UNINSTALL));
+  ValidateItemState(
+      menu, 5,
+      MenuState(app_list::AppContextMenu::SHOW_APP_INFO, false, false));
 }
 
 TEST_F(AppContextMenuTest, ArcMenuStickyItem) {
   ArcAppTest arc_test;
   arc_test.SetUp(profile());
 
   arc_test.app_instance()->RefreshAppList();
   arc_test.app_instance()->SendRefreshAppList(arc_test.fake_apps());
 
   {
     // Verify menu of store
     const arc::mojom::AppInfo& store_info = arc_test.fake_apps()[0];
     const std::string store_id = ArcAppTest::GetAppId(store_info);
     controller()->SetAppPinnable(store_id,
                                  AppListControllerDelegate::PIN_EDITABLE);
     ArcAppItem item(profile(), nullptr, store_id, std::string());
     ui::MenuModel* menu = item.GetContextMenuModel();
     ASSERT_NE(nullptr, menu);
 
-    ASSERT_EQ(4, menu->GetItemCount());
-    EXPECT_EQ(app_list::AppContextMenu::LAUNCH_NEW, menu->GetCommandIdAt(0));
-    EXPECT_TRUE(menu->IsEnabledAt(0));
-    EXPECT_FALSE(menu->IsItemCheckedAt(0));
-    EXPECT_EQ(-1, menu->GetCommandIdAt(1));  // separator
-    EXPECT_EQ(app_list::AppContextMenu::TOGGLE_PIN, menu->GetCommandIdAt(2));
-    EXPECT_TRUE(menu->IsEnabledAt(2));
-    EXPECT_FALSE(menu->IsItemCheckedAt(2));
-    EXPECT_EQ(app_list::AppContextMenu::SHOW_APP_INFO, menu->GetCommandIdAt(3));
-    EXPECT_TRUE(menu->IsEnabledAt(3));
-    EXPECT_FALSE(menu->IsItemCheckedAt(3));
-
-    // No "uninstall" entry.
-  }
-
-  {
-    // Verify normal app menu
-    const arc::mojom::AppInfo& app_info = arc_test.fake_apps()[1];
-    const std::string app_id = ArcAppTest::GetAppId(app_info);
-    controller()->SetAppPinnable(app_id,
-                                 AppListControllerDelegate::PIN_EDITABLE);
-    ArcAppItem item(profile(), nullptr, app_id, std::string());
-    ui::MenuModel* menu = item.GetContextMenuModel();
-    ASSERT_NE(nullptr, menu);
-
-    ASSERT_EQ(6, menu->GetItemCount());
-    EXPECT_EQ(app_list::AppContextMenu::LAUNCH_NEW, menu->GetCommandIdAt(0));
-    EXPECT_TRUE(menu->IsEnabledAt(0));
-    EXPECT_FALSE(menu->IsItemCheckedAt(0));
-    EXPECT_EQ(-1, menu->GetCommandIdAt(1));  // separator
-    EXPECT_EQ(app_list::AppContextMenu::TOGGLE_PIN, menu->GetCommandIdAt(2));
-    EXPECT_TRUE(menu->IsEnabledAt(2));
-    EXPECT_FALSE(menu->IsItemCheckedAt(2));
-    EXPECT_EQ(-1, menu->GetCommandIdAt(3));  // separator
-    EXPECT_EQ(app_list::AppContextMenu::UNINSTALL, menu->GetCommandIdAt(4));
-    EXPECT_TRUE(menu->IsEnabledAt(4));
-    EXPECT_FALSE(menu->IsItemCheckedAt(4));
-    EXPECT_EQ(app_list::AppContextMenu::SHOW_APP_INFO, menu->GetCommandIdAt(5));
-    EXPECT_TRUE(menu->IsEnabledAt(5));
-    EXPECT_FALSE(menu->IsItemCheckedAt(5));
+    ASSERT_EQ(5, menu->GetItemCount());
+    ValidateItemState(menu, 0, MenuState(app_list::AppContextMenu::LAUNCH_NEW));
+    ValidateItemState(menu, 1, MenuState());  // separator
+    ValidateItemState(menu, 2, MenuState(app_list::AppContextMenu::TOGGLE_PIN));
+    ValidateItemState(menu, 3, MenuState());  // separator
+    ValidateItemState(
+        menu, 4, MenuState(app_list::AppContextMenu::SHOW_APP_INFO));
   }
 }
+
 #endif