arc: Fix race conditon when Play Store is started too early.

chrome/browser/ui/app_list/arc/arc_app_unittest.cc

 // Copyright 2015 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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <map>
 #include <memory>
@@ skipping 407 matching lines @@
 
 class ArcDefaulAppTest : public ArcAppModelBuilderTest {
  public:
   ArcDefaulAppTest() = default;
   ~ArcDefaulAppTest() override = default;
 
  protected:
   // ArcAppModelBuilderTest:
   void OnBeforeArcTestSetup() override {
     ArcDefaultAppList::UseTestAppsDirectory();
+    arc_test()->set_wait_default_apps(IsWaitDefaultAppsNeeded());
     arc::ArcPackageSyncableServiceFactory::GetInstance()->SetTestingFactory(
         profile_.get(), nullptr);
   }
 
+  // Returns true if test needs to wait for default apps on setup.
+  virtual bool IsWaitDefaultAppsNeeded() const { return true; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(ArcDefaulAppTest);
 };
 
+class ArcAppLauncherForDefaulAppTest : public ArcDefaulAppTest {
+ public:
+  ArcAppLauncherForDefaulAppTest() = default;
+  ~ArcAppLauncherForDefaulAppTest() override = default;
+
+ protected:
+  // ArcDefaulAppTest:
+  bool IsWaitDefaultAppsNeeded() const override { return false; }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ArcAppLauncherForDefaulAppTest);
+};
+
 class ArcPlayStoreAppTest : public ArcDefaulAppTest {
  public:
   ArcPlayStoreAppTest() = default;
   ~ArcPlayStoreAppTest() override = default;
 
  protected:
   // ArcAppModelBuilderTest:
   void OnBeforeArcTestSetup() override {
     ArcDefaulAppTest::OnBeforeArcTestSetup();
 
@@ skipping 749 matching lines @@
   // App1 is called in deferred mode, after refreshing apps.
   // App2 is never called since app is not avaialble.
   // App3 is never called immediately because app is available already.
   const arc::mojom::AppInfo& app1 = fake_apps()[0];
   const arc::mojom::AppInfo& app2 = fake_apps()[1];
   const arc::mojom::AppInfo& app3 = fake_apps()[2];
   const std::string id1 = ArcAppTest::GetAppId(app1);
   const std::string id2 = ArcAppTest::GetAppId(app2);
   const std::string id3 = ArcAppTest::GetAppId(app3);
 
-  ArcAppLauncher launcher1(profile(), id1, true);
+  ArcAppLauncher launcher1(profile(), id1, true, false);
   EXPECT_FALSE(launcher1.app_launched());
   EXPECT_TRUE(prefs->HasObserver(&launcher1));
 
-  ArcAppLauncher launcher3(profile(), id3, true);
+  ArcAppLauncher launcher3(profile(), id3, true, false);
   EXPECT_FALSE(launcher1.app_launched());
   EXPECT_TRUE(prefs->HasObserver(&launcher1));
   EXPECT_FALSE(launcher3.app_launched());
   EXPECT_TRUE(prefs->HasObserver(&launcher3));
 
   EXPECT_EQ(0u, app_instance()->launch_requests().size());
 
   std::vector<arc::mojom::AppInfo> apps(fake_apps().begin(),
                                         fake_apps().begin() + 2);
   app_instance()->SendRefreshAppList(apps);
 
   EXPECT_TRUE(launcher1.app_launched());
   ASSERT_EQ(1u, app_instance()->launch_requests().size());
   EXPECT_TRUE(app_instance()->launch_requests()[0]->IsForApp(app1));
   EXPECT_FALSE(launcher3.app_launched());
   EXPECT_FALSE(prefs->HasObserver(&launcher1));
   EXPECT_TRUE(prefs->HasObserver(&launcher3));
 
-  ArcAppLauncher launcher2(profile(), id2, true);
+  ArcAppLauncher launcher2(profile(), id2, true, false);
   EXPECT_TRUE(launcher2.app_launched());
   EXPECT_FALSE(prefs->HasObserver(&launcher2));
   ASSERT_EQ(2u, app_instance()->launch_requests().size());
   EXPECT_TRUE(app_instance()->launch_requests()[1]->IsForApp(app2));
 }
 
 // Validates an app that have no launchable flag.
 TEST_P(ArcAppModelBuilderTest, NonLaunchableApp) {
   ArcAppListPrefs* prefs = ArcAppListPrefs::Get(profile_.get());
   ASSERT_NE(nullptr, prefs);
@@ skipping 124 matching lines @@
       fake_default_apps()[0].package_name, package_apps);
   ValidateHaveApps(fake_default_apps());
 
   // Validate that OEM state is preserved.
   for (const auto& default_app : fake_default_apps()) {
     const std::string app_id = ArcAppTest::GetAppId(default_app);
     EXPECT_EQ(oem_states[app_id], prefs->IsOem(app_id));
   }
 }
 
+TEST_P(ArcAppLauncherForDefaulAppTest, AppLauncherForDefaultApps) {
+  ArcAppListPrefs* prefs = ArcAppListPrefs::Get(profile_.get());
+  ASSERT_NE(nullptr, prefs);
+
+  ASSERT_GE(fake_default_apps().size(), 2U);
+  const arc::mojom::AppInfo& app1 = fake_default_apps()[0];
+  const arc::mojom::AppInfo& app2 = fake_default_apps()[1];
+  const std::string id1 = ArcAppTest::GetAppId(app1);
+  const std::string id2 = ArcAppTest::GetAppId(app2);
+
+  // Launch when app is registered and ready.
+  ArcAppLauncher launcher1(profile(), id1, true, false);
+  // Launch when app is registered.
+  ArcAppLauncher launcher2(profile(), id2, true, true);
+
+  EXPECT_FALSE(launcher1.app_launched());
+  EXPECT_FALSE(launcher2.app_launched());
+
+  arc_test()->WaitForDefaultApps();
+
+  // Only second app is expected to be launched.
+  EXPECT_FALSE(launcher1.app_launched());
+  EXPECT_TRUE(launcher2.app_launched());
+
+  app_instance()->RefreshAppList();
+  app_instance()->SendRefreshAppList(fake_default_apps());
+  // Default apps are ready now and it is expected that first app was launched
+  // now.
+  EXPECT_TRUE(launcher1.app_launched());
+}
+
 TEST_P(ArcDefaulAppTest, DefaultAppsNotAvailable) {
   ArcAppListPrefs* prefs = ArcAppListPrefs::Get(profile_.get());
   ASSERT_NE(nullptr, prefs);
 
   ValidateHaveApps(fake_default_apps());
 
   const std::vector<arc::mojom::AppInfo> empty_app_list;
 
   app_instance()->RefreshAppList();
   app_instance()->SendRefreshAppList(empty_app_list);
@@ skipping 69 matching lines @@
   }
 }
 
 INSTANTIATE_TEST_CASE_P(,
                         ArcAppModelBuilderTest,
                         ::testing::ValuesIn(kUnmanagedArcStates));
 INSTANTIATE_TEST_CASE_P(,
                         ArcDefaulAppTest,
                         ::testing::ValuesIn(kUnmanagedArcStates));
 INSTANTIATE_TEST_CASE_P(,
+                        ArcAppLauncherForDefaulAppTest,
+                        ::testing::ValuesIn(kUnmanagedArcStates));
+INSTANTIATE_TEST_CASE_P(,
                         ArcDefaulAppForManagedUserTest,
                         ::testing::ValuesIn(kManagedArcStates));
 INSTANTIATE_TEST_CASE_P(,
                         ArcPlayStoreAppTest,
                         ::testing::ValuesIn(kUnmanagedArcStates));
 INSTANTIATE_TEST_CASE_P(,
                         ArcAppModelBuilderRecreate,
                         ::testing::ValuesIn(kUnmanagedArcStates));