Revert of arc: Use the new InstanceHolder for unittests

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 <string>
 #include <unordered_set>
 #include <vector>
 
 #include "base/macros.h"
@@ skipping 159 matching lines @@
   }
 
   FakeAppContextMenuDelegate* menu_delegate() {
     return menu_delegate_.get();
   }
 
   Profile* profile() {
     return profile_.get();
   }
 
-  void AddSeparator(std::vector<MenuState>* states) {
-    if (states->empty() || states->back().command_id == -1)
+  void AddSeparator(std::vector<MenuState>& states) {
+    if (states.empty() || states.back().command_id == -1)
       return;
-    states->push_back(MenuState());
+    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);
+      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);
+    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()) {
         bool regular_checked = launch_type == extensions::LAUNCH_TYPE_REGULAR;
         states.push_back(MenuState(
             app_list::AppContextMenu::USE_LAUNCH_TYPE_REGULAR,
             true,
             regular_checked));
         states.push_back(MenuState(
             app_list::AppContextMenu::USE_LAUNCH_TYPE_PINNED,
             true,
             launch_type == extensions::LAUNCH_TYPE_PINNED));
         if (extensions::util::CanHostedAppsOpenInWindows()) {
           states.push_back(MenuState(
               app_list::AppContextMenu::USE_LAUNCH_TYPE_WINDOW,
               true,
               launch_type == extensions::LAUNCH_TYPE_WINDOW));
         }
         states.push_back(MenuState(
             app_list::AppContextMenu::USE_LAUNCH_TYPE_FULLSCREEN,
             true,
             launch_type == extensions::LAUNCH_TYPE_FULLSCREEN));
       }
-      AddSeparator(&states);
+      AddSeparator(states);
       states.push_back(MenuState(app_list::AppContextMenu::OPTIONS,
                                  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);
   }
@@ skipping 111 matching lines @@
   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));
 
   // Test activate request.
   EXPECT_EQ(0u, arc_test.app_instance()->launch_requests().size());
 
   menu->ActivatedAt(0);
+  arc_test.app_instance()->WaitForIncomingMethodCall();
 
   const ScopedVector<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();
@@ skipping 77 matching lines @@
     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));
   }
 }
 #endif