Remove more dead app list code.

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/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 "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/arc/test/fake_app_instance.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"
-#endif
-
 namespace {
 
 class FakeAppContextMenuDelegate : public app_list::AppContextMenuDelegate {
  public:
   FakeAppContextMenuDelegate() = default;
   ~FakeAppContextMenuDelegate() override = default;
 
   // app_list::AppContextMenuDelegate overrides:
   void ExecuteLaunchCommand(int event_flags) override {}
 
@@ skipping 15 matching lines @@
     if (open)
       open_apps_.insert(app_id);
     else
       open_apps_.erase(app_id);
   }
 
   bool IsAppOpen(const std::string& app_id) const override {
     return open_apps_.count(app_id) != 0;
   }
 
-  void SetCanCreateShortcuts(bool can_create_shortcuts) {
-    can_create_shortcuts_ = can_create_shortcuts;
-  }
-
   void SetCanShowAppInfo(bool can_show_app_info) {
     can_show_app_info_ = can_show_app_info;
   }
 
   // test::TestAppListControllerDelegate overrides:
   Pinnable GetPinnable(const std::string& app_id) override {
     std::map<std::string, Pinnable>::const_iterator it;
     it = pinnable_apps_.find(app_id);
     if (it == pinnable_apps_.end())
       return NO_PIN;
     return it->second;
   }
-  bool CanDoCreateShortcutsFlow() override { return can_create_shortcuts_; }
   bool CanDoShowAppInfoFlow() override { return can_show_app_info_; }
 
  private:
   std::map<std::string, Pinnable> pinnable_apps_;
   std::unordered_set<std::string> open_apps_;
-  bool can_create_shortcuts_ = false;
   bool can_show_app_info_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(FakeAppListControllerDelegate);
 };
 
 std::unique_ptr<KeyedService> MenuManagerFactory(
     content::BrowserContext* context) {
   return extensions::MenuManagerFactory::BuildServiceInstanceForTesting(
               context);
 }
@@ skipping 83 matching lines @@
   }
 
   void AddSeparator(std::vector<MenuState>* states) {
     if (states->empty() || states->back().command_id == -1)
       return;
     states->push_back(MenuState());
   }
 
   void TestExtensionApp(const std::string& app_id,
                         bool platform_app,
-                        bool can_create_shortcuts,
                         bool can_show_app_info,
                         AppListControllerDelegate::Pinnable pinnable,
                         extensions::LaunchType launch_type) {
     controller_.reset(new FakeAppListControllerDelegate());
     controller_->SetAppPinnable(app_id, pinnable);
-    controller_->SetCanCreateShortcuts(can_create_shortcuts);
     controller_->SetCanShowAppInfo(can_show_app_info);
     controller_->SetExtensionLaunchType(profile(), app_id, launch_type);
     app_list::ExtensionAppContextMenu menu(menu_delegate(),
                                            profile(),
                                            app_id,
                                            controller());
     menu.set_is_platform_app(platform_app);
     ui::MenuModel* menu_model = menu.GetMenuModel();
     ASSERT_NE(nullptr, menu_model);
 
     std::vector<MenuState> states;
     if (!platform_app)
       states.push_back(MenuState(app_list::AppContextMenu::LAUNCH_NEW));
     if (pinnable != AppListControllerDelegate::NO_PIN) {
       AddSeparator(&states);
       states.push_back(MenuState(
           app_list::AppContextMenu::TOGGLE_PIN,
           pinnable != AppListControllerDelegate::PIN_FIXED,
           false));
     }
-    if (can_create_shortcuts)
-      states.push_back(MenuState(app_list::AppContextMenu::CREATE_SHORTCUTS));
     AddSeparator(&states);
 
     if (!platform_app) {
       if (extensions::util::CanHostedAppsOpenInWindows() &&
           extensions::util::IsNewBookmarkAppsEnabled()) {
         bool checked = launch_type == extensions::LAUNCH_TYPE_WINDOW ||
             launch_type == extensions::LAUNCH_TYPE_FULLSCREEN;
         states.push_back(MenuState(
             app_list::AppContextMenu::USE_LAUNCH_TYPE_WINDOW, true, checked));
       } else if (!extensions::util::IsNewBookmarkAppsEnabled()) {
@@ skipping 22 matching lines @@
                                  false,
                                  false));
     }
     states.push_back(MenuState(app_list::AppContextMenu::UNINSTALL));
     if (can_show_app_info)
       states.push_back(MenuState(app_list::AppContextMenu::SHOW_APP_INFO));
 
     ValidateMenuState(menu_model, states);
   }
 
-  void TestChromeApp(bool can_create_shortcuts,
-                     bool can_show_app_info) {
+  void TestChromeApp(bool can_show_app_info) {
     controller_.reset(new FakeAppListControllerDelegate());
-    controller_->SetCanCreateShortcuts(can_create_shortcuts);
     controller_->SetCanShowAppInfo(can_show_app_info);
     app_list::ExtensionAppContextMenu menu(menu_delegate(),
                                            profile(),
                                            extension_misc::kChromeAppId,
                                            controller());
     ui::MenuModel* menu_model = menu.GetMenuModel();
     ASSERT_NE(nullptr, menu_model);
 
     std::vector<MenuState> states;
     states.push_back(MenuState(app_list::AppContextMenu::MENU_NEW_WINDOW));
@@ skipping 19 matching lines @@
   app_list::ExtensionAppContextMenu::DisableInstalledExtensionCheckForTesting(
       false);
   for (extensions::LaunchType launch_type = extensions::LAUNCH_TYPE_FIRST;
       launch_type < extensions::NUM_LAUNCH_TYPES;
       launch_type = static_cast<extensions::LaunchType>(launch_type+1)) {
     AppListControllerDelegate::Pinnable pinnable;
     for (pinnable = AppListControllerDelegate::NO_PIN;
         pinnable <= AppListControllerDelegate::PIN_FIXED;
         pinnable =
             static_cast<AppListControllerDelegate::Pinnable>(pinnable+1)) {
-      for (size_t combinations = 0; combinations < (1 << 3); ++combinations) {
+      for (size_t combinations = 0; combinations < (1 << 2); ++combinations) {
         TestExtensionApp(AppListTestBase::kHostedAppId,
                          (combinations & (1 << 0)) != 0,
                          (combinations & (1 << 1)) != 0,
-                         (combinations & (1 << 2)) != 0,
                          pinnable,
                          launch_type);
         TestExtensionApp(AppListTestBase::kPackagedApp1Id,
                          (combinations & (1 << 0)) != 0,
                          (combinations & (1 << 1)) != 0,
-                         (combinations & (1 << 2)) != 0,
                          pinnable,
                          launch_type);
         TestExtensionApp(AppListTestBase::kPackagedApp2Id,
                          (combinations & (1 << 0)) != 0,
                          (combinations & (1 << 1)) != 0,
-                         (combinations & (1 << 2)) != 0,
                          pinnable,
                          launch_type);
       }
     }
   }
 }
 
 TEST_F(AppContextMenuTest, ChromeApp) {
   app_list::ExtensionAppContextMenu::DisableInstalledExtensionCheckForTesting(
       true);
-  for (size_t combinations = 0; combinations < (1 << 2); ++combinations) {
-    TestChromeApp((combinations & (1 << 0)) != 0,
-                  (combinations & (1 << 1)) != 0);
-  }
+  for (bool can_show_app_info : {true, false})
+    TestChromeApp(can_show_app_info);
 }
 
 TEST_F(AppContextMenuTest, NonExistingExtensionApp) {
   app_list::ExtensionAppContextMenu::DisableInstalledExtensionCheckForTesting(
       false);
   app_list::ExtensionAppContextMenu menu(menu_delegate(),
                                          profile(),
                                          "some_non_existing_extension_app",
                                          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()[1];
   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());
@@ skipping 123 matching lines @@
 
     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