arc: Prevent App list popping on each app installed from batch.

chrome/browser/ui/ash/launcher/arc_app_launcher_browsertest.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 "ash/common/shelf/shelf_delegate.h"
 #include "ash/common/wm_shell.h"
 #include "ash/wm/window_util.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
@@ skipping 40 matching lines @@
 
 }  // namespace mojo
 
 namespace {
 
 constexpr char kTestAppName[] = "Test Arc App";
 constexpr char kTestAppName2[] = "Test Arc App 2";
 constexpr char kTestShortcutName[] = "Test Shortcut";
 constexpr char kTestShortcutName2[] = "Test Shortcut 2";
 constexpr char kTestAppPackage[] = "test.arc.app.package";
+constexpr char kTestAppPackage2[] = "test.arc.app.package2";
+constexpr char kTestAppPackage3[] = "test.arc.app.package3";
 constexpr char kTestAppActivity[] = "test.arc.app.package.activity";
 constexpr char kTestAppActivity2[] = "test.arc.gitapp.package.activity2";
 constexpr char kTestShelfGroup[] = "shelf_group";
 constexpr char kTestShelfGroup2[] = "shelf_group_2";
 constexpr char kTestShelfGroup3[] = "shelf_group_3";
 constexpr int kAppAnimatedThresholdMs = 100;
 
-std::string GetTestApp1Id() {
-  return ArcAppListPrefs::GetAppId(kTestAppPackage, kTestAppActivity);
+std::string GetTestApp1Id(const std::string& package_name) {
+  return ArcAppListPrefs::GetAppId(package_name, kTestAppActivity);
 }
 
-std::string GetTestApp2Id() {
-  return ArcAppListPrefs::GetAppId(kTestAppPackage, kTestAppActivity2);
+std::string GetTestApp2Id(const std::string& package_name) {
+  return ArcAppListPrefs::GetAppId(package_name, kTestAppActivity2);
 }
 
-std::vector<arc::mojom::AppInfoPtr> GetTestAppsList(bool multi_app) {
+std::vector<arc::mojom::AppInfoPtr> GetTestAppsList(
+    const std::string& package_name,
+    bool multi_app) {
   std::vector<arc::mojom::AppInfoPtr> apps;
 
   arc::mojom::AppInfoPtr app(arc::mojom::AppInfo::New());
   app->name = kTestAppName;
-  app->package_name = kTestAppPackage;
+  app->package_name = package_name;
   app->activity = kTestAppActivity;
   app->sticky = false;
   apps.push_back(std::move(app));
 
   if (multi_app) {
     app = arc::mojom::AppInfo::New();
     app->name = kTestAppName2;
-    app->package_name = kTestAppPackage;
+    app->package_name = package_name;
     app->activity = kTestAppActivity2;
     app->sticky = false;
     apps.push_back(std::move(app));
   }
 
   return apps;
 }
 
 ChromeLauncherController* chrome_controller() {
   return ChromeLauncherController::instance();
@@ skipping 58 matching lines @@
 
   void SetUpInProcessBrowserTestFixture() override {
     ExtensionBrowserTest::SetUpInProcessBrowserTestFixture();
     arc::ArcSessionManager::DisableUIForTesting();
   }
 
   void SetUpOnMainThread() override {
     arc::ArcSessionManager::Get()->EnableArc();
   }
 
-  void InstallTestApps(bool multi_app) {
-    app_host()->OnAppListRefreshed(GetTestAppsList(multi_app));
+  void InstallTestApps(const std::string& package_name, bool multi_app) {
+    app_host()->OnAppListRefreshed(GetTestAppsList(package_name, multi_app));
 
     std::unique_ptr<ArcAppListPrefs::AppInfo> app_info =
-        app_prefs()->GetApp(GetTestApp1Id());
+        app_prefs()->GetApp(GetTestApp1Id(package_name));
     ASSERT_TRUE(app_info);
     EXPECT_TRUE(app_info->ready);
     if (multi_app) {
       std::unique_ptr<ArcAppListPrefs::AppInfo> app_info2 =
-          app_prefs()->GetApp(GetTestApp2Id());
+          app_prefs()->GetApp(GetTestApp2Id(package_name));
       ASSERT_TRUE(app_info2);
       EXPECT_TRUE(app_info2->ready);
     }
   }
 
   std::string InstallShortcut(const std::string& name,
                               const std::string& shelf_group) {
     arc::mojom::ShortcutInfo shortcut;
     shortcut.name = name;
     shortcut.package_name = kTestAppPackage;
     shortcut.intent_uri = CreateIntentUriWithShelfGroup(shelf_group);
     const std::string shortcut_id =
         ArcAppListPrefs::GetAppId(shortcut.package_name, shortcut.intent_uri);
     app_host()->OnInstallShortcut(arc::mojom::ShortcutInfo::From(shortcut));
     base::RunLoop().RunUntilIdle();
 
     std::unique_ptr<ArcAppListPrefs::AppInfo> shortcut_info =
         app_prefs()->GetApp(shortcut_id);
 
     CHECK(shortcut_info);
     EXPECT_TRUE(shortcut_info->shortcut);
     EXPECT_EQ(kTestAppPackage, shortcut_info->package_name);
     EXPECT_EQ(shortcut.intent_uri, shortcut_info->intent_uri);
     return shortcut_id;
   }
 
-  void SendPackageAdded(bool package_synced) {
+  void SendPackageAdded(const std::string& package_name, bool package_synced) {
     arc::mojom::ArcPackageInfo package_info;
-    package_info.package_name = kTestAppPackage;
+    package_info.package_name = package_name;
     package_info.package_version = 1;
     package_info.last_backup_android_id = 1;
     package_info.last_backup_time = 1;
     package_info.sync = package_synced;
     package_info.system = false;
     app_host()->OnPackageAdded(arc::mojom::ArcPackageInfo::From(package_info));
 
     base::RunLoop().RunUntilIdle();
   }
 
-  void SendPackageUpdated(bool multi_app) {
-    app_host()->OnPackageAppListRefreshed(kTestAppPackage,
-                                          GetTestAppsList(multi_app));
+  void SendPackageUpdated(const std::string& package_name, bool multi_app) {
+    app_host()->OnPackageAppListRefreshed(
+        package_name, GetTestAppsList(package_name, multi_app));
   }
 
-  void SendPackageRemoved() { app_host()->OnPackageRemoved(kTestAppPackage); }
+  void SendPackageRemoved(const std::string& package_name) {
+    app_host()->OnPackageRemoved(package_name);
+  }
+
+  void SendInstallationStarted() {
+    app_host()->OnInstallationStarted();
+    base::RunLoop().RunUntilIdle();
+  }
+
+  void SendInstallationFinished() {
+    app_host()->OnInstallationFinished();
+    base::RunLoop().RunUntilIdle();
+  }
 
   void StartInstance() {
     if (arc_session_manager()->profile() != profile())
       arc_session_manager()->OnPrimaryUserProfilePrepared(profile());
     app_instance_observer()->OnInstanceReady();
   }
 
   void StopInstance() {
     arc_session_manager()->Shutdown();
     app_instance_observer()->OnInstanceClosed();
@@ skipping 40 matching lines @@
   TestAction test_action() const { return std::tr1::get<0>(GetParam()); }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ArcAppDeferredLauncherBrowserTest);
 };
 
 // This tests simulates normal workflow for starting Arc app in deferred mode.
 IN_PROC_BROWSER_TEST_P(ArcAppDeferredLauncherBrowserTest, StartAppDeferred) {
   // Install app to remember existing apps.
   StartInstance();
-  InstallTestApps(false);
-  SendPackageAdded(false);
+  InstallTestApps(kTestAppPackage, false);
+  SendPackageAdded(kTestAppPackage, false);
 
-  const std::string app_id = GetTestApp1Id();
+  const std::string app_id = GetTestApp1Id(kTestAppPackage);
   if (is_pinned()) {
     shelf_delegate()->PinAppWithID(app_id);
     EXPECT_TRUE(shelf_delegate()->GetShelfIDForAppID(app_id));
   } else {
     EXPECT_FALSE(shelf_delegate()->GetShelfIDForAppID(app_id));
   }
 
   StopInstance();
   std::unique_ptr<ArcAppListPrefs::AppInfo> app_info =
       app_prefs()->GetApp(app_id);
@@ skipping 12 matching lines @@
 
   // Launching non-ready Arc app creates item on shelf and spinning animation.
   arc::LaunchApp(profile(), app_id, ui::EF_LEFT_MOUSE_BUTTON);
   EXPECT_TRUE(shelf_delegate()->GetShelfIDForAppID(app_id));
   AppAnimatedWaiter(app_id).Wait();
 
   switch (test_action()) {
     case TEST_ACTION_START:
       // Now simulates that Arc is started and app list is refreshed. This
       // should stop animation and delete icon from the shelf.
-      InstallTestApps(false);
-      SendPackageAdded(false);
+      InstallTestApps(kTestAppPackage, false);
+      SendPackageAdded(kTestAppPackage, false);
       EXPECT_TRUE(chrome_controller()
                       ->GetArcDeferredLauncher()
                       ->GetActiveTime(app_id)
                       .is_zero());
       if (is_pinned())
         EXPECT_TRUE(shelf_delegate()->GetShelfIDForAppID(app_id));
       else
         EXPECT_FALSE(shelf_delegate()->GetShelfIDForAppID(app_id));
       break;
     case TEST_ACTION_EXIT:
@@ skipping 23 matching lines @@
                         ::testing::ValuesIn(build_test_parameter));
 
 // This tests validates pin state on package update and remove.
 IN_PROC_BROWSER_TEST_F(ArcAppLauncherBrowserTest, PinOnPackageUpdateAndRemove) {
   StartInstance();
 
   // Make use app list sync service is started. Normally it is started when
   // sycing is initialized.
   app_list::AppListSyncableServiceFactory::GetForProfile(profile())->GetModel();
 
-  InstallTestApps(true);
-  SendPackageAdded(false);
+  InstallTestApps(kTestAppPackage, true);
+  SendPackageAdded(kTestAppPackage, false);
 
-  const std::string app_id1 = GetTestApp1Id();
-  const std::string app_id2 = GetTestApp2Id();
+  const std::string app_id1 = GetTestApp1Id(kTestAppPackage);
+  const std::string app_id2 = GetTestApp2Id(kTestAppPackage);
   shelf_delegate()->PinAppWithID(app_id1);
   shelf_delegate()->PinAppWithID(app_id2);
   const ash::ShelfID shelf_id1_before =
       shelf_delegate()->GetShelfIDForAppID(app_id1);
   EXPECT_TRUE(shelf_id1_before);
   EXPECT_TRUE(shelf_delegate()->GetShelfIDForAppID(app_id2));
 
   // Package contains only one app. App list is not shown for updated package.
-  SendPackageUpdated(false);
+  SendPackageUpdated(kTestAppPackage, false);
   // Second pin should gone.
   EXPECT_EQ(shelf_id1_before, shelf_delegate()->GetShelfIDForAppID(app_id1));
   EXPECT_FALSE(shelf_delegate()->GetShelfIDForAppID(app_id2));
 
   // Package contains two apps. App list is not shown for updated package.
-  SendPackageUpdated(true);
+  SendPackageUpdated(kTestAppPackage, true);
   // Second pin should not appear.
   EXPECT_EQ(shelf_id1_before, shelf_delegate()->GetShelfIDForAppID(app_id1));
   EXPECT_FALSE(shelf_delegate()->GetShelfIDForAppID(app_id2));
 
   // Package removed.
-  SendPackageRemoved();
+  SendPackageRemoved(kTestAppPackage);
   // No pin is expected.
   EXPECT_FALSE(shelf_delegate()->GetShelfIDForAppID(app_id1));
   EXPECT_FALSE(shelf_delegate()->GetShelfIDForAppID(app_id2));
 }
 
 // This test validates that app list is shown on new package and not shown
 // on package update.
 IN_PROC_BROWSER_TEST_F(ArcAppLauncherBrowserTest, AppListShown) {
   StartInstance();
   AppListService* app_list_service = AppListService::Get();
   ASSERT_TRUE(app_list_service);
 
   EXPECT_FALSE(app_list_service->IsAppListVisible());
 
+  SendInstallationStarted();
+  SendInstallationStarted();
+
   // New package is available. Show app list.
-  InstallTestApps(false);
-  SendPackageAdded(true);
+  SendInstallationFinished();
+  InstallTestApps(kTestAppPackage, false);
+  SendPackageAdded(kTestAppPackage, true);
   EXPECT_TRUE(app_list_service->IsAppListVisible());
 
   app_list_service->DismissAppList();
   EXPECT_FALSE(app_list_service->IsAppListVisible());
 
   // Send package update event. App list is not shown.
-  SendPackageAdded(true);
+  SendPackageAdded(kTestAppPackage, true);
   EXPECT_FALSE(app_list_service->IsAppListVisible());
+
+  // Install next package from batch. Next new package is available.
+  // Don't show app list.
+  SendInstallationFinished();
+  InstallTestApps(kTestAppPackage2, false);
+  SendPackageAdded(kTestAppPackage2, true);
+  EXPECT_FALSE(app_list_service->IsAppListVisible());
+
+  // Run next installation batch. App list should be shown again.
+  SendInstallationStarted();
+  SendInstallationFinished();
+  InstallTestApps(kTestAppPackage3, false);
+  SendPackageAdded(kTestAppPackage3, true);
+  EXPECT_TRUE(app_list_service->IsAppListVisible());
+  app_list_service->DismissAppList();
 }
 
 // Test AppListControllerDelegate::IsAppOpen for Arc apps.
 IN_PROC_BROWSER_TEST_F(ArcAppLauncherBrowserTest, IsAppOpen) {
   StartInstance();
-  InstallTestApps(false);
-  SendPackageAdded(true);
-  const std::string app_id = GetTestApp1Id();
+  InstallTestApps(kTestAppPackage, false);
+  SendPackageAdded(kTestAppPackage, true);
+  const std::string app_id = GetTestApp1Id(kTestAppPackage);
 
   AppListService* service = AppListService::Get();
   AppListControllerDelegate* delegate = service->GetControllerDelegate();
   EXPECT_FALSE(delegate->IsAppOpen(app_id));
   arc::LaunchApp(profile(), app_id, ui::EF_LEFT_MOUSE_BUTTON);
   EXPECT_FALSE(delegate->IsAppOpen(app_id));
   // Simulate task creation so the app is marked as running/open.
   std::unique_ptr<ArcAppListPrefs::AppInfo> info = app_prefs()->GetApp(app_id);
   app_host()->OnTaskCreated(0, info->package_name, info->activity, info->name,
                             info->intent_uri);
   EXPECT_TRUE(delegate->IsAppOpen(app_id));
 }
 
 // Test Shelf Groups
 IN_PROC_BROWSER_TEST_F(ArcAppLauncherBrowserTest, ShelfGroup) {
   StartInstance();
-  InstallTestApps(false);
-  SendPackageAdded(true);
+  InstallTestApps(kTestAppPackage, false);
+  SendPackageAdded(kTestAppPackage, true);
   const std::string shorcut_id1 =
       InstallShortcut(kTestShortcutName, kTestShelfGroup);
   const std::string shorcut_id2 =
       InstallShortcut(kTestShortcutName2, kTestShelfGroup2);
 
-  const std::string app_id = GetTestApp1Id();
+  const std::string app_id = GetTestApp1Id(kTestAppPackage);
   std::unique_ptr<ArcAppListPrefs::AppInfo> info = app_prefs()->GetApp(app_id);
   ASSERT_TRUE(info);
 
   const std::string shelf_id1 =
       arc::ArcAppShelfId(kTestShelfGroup, app_id).ToString();
   const std::string shelf_id2 =
       arc::ArcAppShelfId(kTestShelfGroup2, app_id).ToString();
   const std::string shelf_id3 =
       arc::ArcAppShelfId(kTestShelfGroup3, app_id).ToString();
 
@@ skipping 39 matching lines @@
   app_host()->OnTaskDestroyed(2);
   EXPECT_EQ(controller2, GetAppItemController(shelf_id2));
   // Destroy task #2, this kills shelf group 2
   app_host()->OnTaskDestroyed(3);
   EXPECT_FALSE(GetAppItemController(shelf_id2));
 
   // Disable Arc, this removes app and as result kills shelf group 3.
   arc::ArcSessionManager::Get()->DisableArc();
   EXPECT_FALSE(GetAppItemController(shelf_id3));
 }