[Merge to M53] arc: Initial implemetation of Chrome sync for Arc packages.

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 <string>
@@ skipping 279 matching lines @@
   }
 
   void RemovePackage(const arc::mojom::ArcPackageInfo& package) {
     arc_test_.RemovePackage(package);
   }
 
   AppListControllerDelegate* controller() { return controller_.get(); }
 
   Profile* profile() { return profile_.get(); }
 
+  ArcAppTest* arc_test() { return &arc_test_; }
+
   const std::vector<arc::mojom::AppInfo>& fake_apps() const {
     return arc_test_.fake_apps();
   }
 
   const std::vector<arc::mojom::ArcPackageInfo>& fake_packages() const {
     return arc_test_.fake_packages();
   }
 
   const std::vector<arc::mojom::ShortcutInfo>& fake_shortcuts() const {
     return arc_test_.fake_shortcuts();
   }
 
-  arc::FakeArcBridgeService* bridge_service() {
-    return arc_test_.bridge_service();
-  }
-
   arc::FakeAppInstance* app_instance() {
     return arc_test_.app_instance();
   }
 
  private:
   ArcAppTest arc_test_;
   std::unique_ptr<app_list::AppListModel> model_;
   std::unique_ptr<test::TestAppListControllerDelegate> controller_;
   std::unique_ptr<ArcAppModelBuilder> builder_;
 
   DISALLOW_COPY_AND_ASSIGN(ArcAppModelBuilderTest);
 };
 
 TEST_F(ArcAppModelBuilderTest, ArcPackagePref) {
   ValidateHavePackages(std::vector<arc::mojom::ArcPackageInfo>());
-  bridge_service()->SetReady();
   app_instance()->SendRefreshPackageList(fake_packages());
   ValidateHavePackages(fake_packages());
 
   arc::mojom::ArcPackageInfo package;
   package.package_name = kTestPackageName;
   package.package_version = 2;
   package.last_backup_android_id = 2;
   package.last_backup_time = 2;
   package.sync = true;
 
   RemovePackage(package);
   app_instance()->SendPackageUninstalled(package.package_name);
   ValidateHavePackages(fake_packages());
 
   AddPackage(package);
   app_instance()->SendPackageAdded(package);
   ValidateHavePackages(fake_packages());
 }
 
 TEST_F(ArcAppModelBuilderTest, RefreshAllOnReady) {
   // There should already have been one call, when the interface was
   // registered.
   EXPECT_EQ(1, app_instance()->refresh_app_list_count());
-  bridge_service()->SetReady();
   app_instance()->RefreshAppList();
   EXPECT_EQ(2, app_instance()->refresh_app_list_count());
 }
 
 TEST_F(ArcAppModelBuilderTest, RefreshAllFillsContent) {
   ValidateHaveApps(std::vector<arc::mojom::AppInfo>());
-  bridge_service()->SetReady();
   app_instance()->RefreshAppList();
   app_instance()->SendRefreshAppList(fake_apps());
   ValidateHaveApps(fake_apps());
 }
 
 TEST_F(ArcAppModelBuilderTest, InstallShortcut) {
   ValidateHaveApps(std::vector<arc::mojom::AppInfo>());
-  bridge_service()->SetReady();
 
   app_instance()->SendInstallShortcuts(fake_shortcuts());
   ValidateHaveShortcuts(fake_shortcuts());
 }
 
 TEST_F(ArcAppModelBuilderTest, RefreshAllPreservesShortcut) {
   ValidateHaveApps(std::vector<arc::mojom::AppInfo>());
-  bridge_service()->SetReady();
   app_instance()->RefreshAppList();
   app_instance()->SendRefreshAppList(fake_apps());
   ValidateHaveApps(fake_apps());
 
   app_instance()->SendInstallShortcuts(fake_shortcuts());
   ValidateHaveAppsAndShortcuts(fake_apps(), fake_shortcuts());
 
   app_instance()->RefreshAppList();
   app_instance()->SendRefreshAppList(fake_apps());
   ValidateHaveAppsAndShortcuts(fake_apps(), fake_shortcuts());
 }
 
 TEST_F(ArcAppModelBuilderTest, MultipleRefreshAll) {
   ValidateHaveApps(std::vector<arc::mojom::AppInfo>());
-  bridge_service()->SetReady();
   app_instance()->RefreshAppList();
   // Send info about all fake apps except last.
   std::vector<arc::mojom::AppInfo> apps1(fake_apps().begin(),
                                          fake_apps().end() - 1);
   app_instance()->SendRefreshAppList(apps1);
   // At this point all apps (except last) should exist and be ready.
   ValidateHaveApps(apps1);
   ValidateAppReadyState(apps1, true);
 
   // Send info about all fake apps except first.
@@ skipping 14 matching lines @@
   std::vector<arc::mojom::AppInfo> no_apps;
   app_instance()->SendRefreshAppList(no_apps);
   // At this point no app should exist.
   ValidateHaveApps(no_apps);
 }
 
 TEST_F(ArcAppModelBuilderTest, StopStartServicePreserveApps) {
   ArcAppListPrefs* prefs = ArcAppListPrefs::Get(profile_.get());
   ASSERT_NE(nullptr, prefs);
 
-  bridge_service()->SetReady();
   app_instance()->RefreshAppList();
   EXPECT_EQ(0u, GetArcItemCount());
   EXPECT_EQ(0u, prefs->GetAppIds().size());
 
   app_instance()->SendRefreshAppList(fake_apps());
   std::vector<std::string> ids = prefs->GetAppIds();
   EXPECT_EQ(fake_apps().size(), ids.size());
   ValidateAppReadyState(fake_apps(), true);
 
   // Stopping service does not delete items. It makes them non-ready.
-  bridge_service()->SetStopped();
+  arc_test()->StopArcInstance();
   // Ids should be the same.
   EXPECT_EQ(ids, prefs->GetAppIds());
   ValidateAppReadyState(fake_apps(), false);
 
-  // Setting service ready does not change anything because RefreshAppList is
-  // not called.
-  bridge_service()->SetReady();
   // Ids should be the same.
   EXPECT_EQ(ids, prefs->GetAppIds());
   ValidateAppReadyState(fake_apps(), false);
 
   // Refreshing app list makes apps available.
   app_instance()->SendRefreshAppList(fake_apps());
   EXPECT_EQ(ids, prefs->GetAppIds());
   ValidateAppReadyState(fake_apps(), true);
 }
 
 TEST_F(ArcAppModelBuilderTest, StopStartServicePreserveShortcuts) {
   ArcAppListPrefs* prefs = ArcAppListPrefs::Get(profile_.get());
   ASSERT_NE(nullptr, prefs);
 
-  bridge_service()->SetReady();
   app_instance()->RefreshAppList();
   EXPECT_EQ(0u, GetArcItemCount());
   EXPECT_EQ(0u, prefs->GetAppIds().size());
 
   app_instance()->SendInstallShortcuts(fake_shortcuts());
   std::vector<std::string> ids = prefs->GetAppIds();
   EXPECT_EQ(fake_shortcuts().size(), ids.size());
   ValidateShortcutReadyState(fake_shortcuts(), true);
 
   // Stopping service does not delete items. It makes them non-ready.
-  bridge_service()->SetStopped();
+  arc_test()->StopArcInstance();
   // Ids should be the same.
   EXPECT_EQ(ids, prefs->GetAppIds());
   ValidateShortcutReadyState(fake_shortcuts(), false);
 
-  // Setting service ready does not change anything because RefreshAppList is
-  // not called.
-  bridge_service()->SetReady();
   // Ids should be the same.
   EXPECT_EQ(ids, prefs->GetAppIds());
   ValidateShortcutReadyState(fake_shortcuts(), false);
 
   // Refreshing app list makes apps available.
   app_instance()->RefreshAppList();
   app_instance()->SendRefreshAppList(std::vector<arc::mojom::AppInfo>());
   EXPECT_EQ(ids, prefs->GetAppIds());
   ValidateShortcutReadyState(fake_shortcuts(), true);
 }
 
 TEST_F(ArcAppModelBuilderTest, RestartPreserveApps) {
   ArcAppListPrefs* prefs = ArcAppListPrefs::Get(profile_.get());
   ASSERT_NE(nullptr, prefs);
 
   // Start from scratch and fill with apps.
-  bridge_service()->SetReady();
   app_instance()->SendRefreshAppList(fake_apps());
   std::vector<std::string> ids = prefs->GetAppIds();
   EXPECT_EQ(fake_apps().size(), ids.size());
   ValidateAppReadyState(fake_apps(), true);
 
   // This recreates model and ARC apps will be read from prefs.
-  bridge_service()->SetStopped();
+  arc_test()->StopArcInstance();
   CreateBuilder();
   ValidateAppReadyState(fake_apps(), false);
 }
 
 TEST_F(ArcAppModelBuilderTest, RestartPreserveShortcuts) {
   ArcAppListPrefs* prefs = ArcAppListPrefs::Get(profile_.get());
   ASSERT_NE(nullptr, prefs);
 
   // Start from scratch and install shortcuts.
-  bridge_service()->SetReady();
   app_instance()->SendInstallShortcuts(fake_shortcuts());
   std::vector<std::string> ids = prefs->GetAppIds();
   EXPECT_EQ(fake_apps().size(), ids.size());
   ValidateShortcutReadyState(fake_shortcuts(), true);
 
   // This recreates model and ARC apps and shortcuts will be read from prefs.
-  bridge_service()->SetStopped();
+  arc_test()->StopArcInstance();
   CreateBuilder();
   ValidateShortcutReadyState(fake_shortcuts(), false);
 }
 
 TEST_F(ArcAppModelBuilderTest, LaunchApps) {
   // Disable attempts to dismiss app launcher view.
   ChromeAppListItem::OverrideAppListControllerDelegateForTesting(controller());
 
-  bridge_service()->SetReady();
   app_instance()->RefreshAppList();
   app_instance()->SendRefreshAppList(fake_apps());
 
   // Simulate item activate.
   const arc::mojom::AppInfo& app_first = fake_apps()[0];
   const arc::mojom::AppInfo& app_last = fake_apps()[0];
   ArcAppItem* item_first = FindArcItem(ArcAppTest::GetAppId(app_first));
   ArcAppItem* item_last = FindArcItem(ArcAppTest::GetAppId(app_last));
   ASSERT_NE(nullptr, item_first);
   ASSERT_NE(nullptr, item_last);
   item_first->Activate(0);
-  app_instance()->WaitForIncomingMethodCall();
   item_last->Activate(0);
-  app_instance()->WaitForIncomingMethodCall();
   item_first->Activate(0);
-  app_instance()->WaitForIncomingMethodCall();
 
   const ScopedVector<arc::FakeAppInstance::Request>& launch_requests =
       app_instance()->launch_requests();
   ASSERT_EQ(3u, launch_requests.size());
   EXPECT_EQ(true, launch_requests[0]->IsForApp(app_first));
   EXPECT_EQ(true, launch_requests[1]->IsForApp(app_last));
   EXPECT_EQ(true, launch_requests[2]->IsForApp(app_first));
 
   // Test an attempt to launch of a not-ready app.
-  bridge_service()->SetStopped();
+  arc_test()->StopArcInstance();
   item_first = FindArcItem(ArcAppTest::GetAppId(app_first));
   ASSERT_NE(nullptr, item_first);
   size_t launch_request_count_before = app_instance()->launch_requests().size();
   item_first->Activate(0);
   // Number of launch requests must not change.
   EXPECT_EQ(launch_request_count_before,
             app_instance()->launch_requests().size());
 }
 
 TEST_F(ArcAppModelBuilderTest, LaunchShortcuts) {
   // Disable attempts to dismiss app launcher view.
   ChromeAppListItem::OverrideAppListControllerDelegateForTesting(controller());
 
-  bridge_service()->SetReady();
   app_instance()->RefreshAppList();
   app_instance()->SendInstallShortcuts(fake_shortcuts());
 
   // Simulate item activate.
   const arc::mojom::ShortcutInfo& app_first = fake_shortcuts()[0];
   const arc::mojom::ShortcutInfo& app_last = fake_shortcuts()[0];
   ArcAppItem* item_first = FindArcItem(ArcAppTest::GetAppId(app_first));
   ArcAppItem* item_last = FindArcItem(ArcAppTest::GetAppId(app_last));
   ASSERT_NE(nullptr, item_first);
   ASSERT_NE(nullptr, item_last);
   item_first->Activate(0);
-  app_instance()->WaitForIncomingMethodCall();
   item_last->Activate(0);
-  app_instance()->WaitForIncomingMethodCall();
   item_first->Activate(0);
-  app_instance()->WaitForIncomingMethodCall();
 
   const ScopedVector<mojo::String>& launch_intents =
       app_instance()->launch_intents();
   ASSERT_EQ(3u, launch_intents.size());
   EXPECT_EQ(true, app_first.intent_uri == *launch_intents[0]);
   EXPECT_EQ(true, app_last.intent_uri == *launch_intents[1]);
   EXPECT_EQ(true, app_first.intent_uri == *launch_intents[2]);
 
   // Test an attempt to launch of a not-ready shortcut.
-  bridge_service()->SetStopped();
+  arc_test()->StopArcInstance();
   item_first = FindArcItem(ArcAppTest::GetAppId(app_first));
   ASSERT_NE(nullptr, item_first);
   size_t launch_request_count_before = app_instance()->launch_intents().size();
   item_first->Activate(0);
   // Number of launch requests must not change.
   EXPECT_EQ(launch_request_count_before,
             app_instance()->launch_intents().size());
 }
 
 TEST_F(ArcAppModelBuilderTest, RequestIcons) {
   // Make sure we are on UI thread.
   ASSERT_TRUE(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
-  bridge_service()->SetReady();
   app_instance()->RefreshAppList();
   app_instance()->SendRefreshAppList(fake_apps());
 
   // Validate that no icon exists at the beginning and request icon for
   // each supported scale factor. This will start asynchronous loading.
   uint32_t expected_mask = 0;
   const std::vector<ui::ScaleFactor>& scale_factors =
       ui::GetSupportedScaleFactors();
   for (auto& scale_factor : scale_factors) {
     expected_mask |= 1 <<  scale_factor;
     for (auto& app : fake_apps()) {
       ArcAppItem* app_item = FindArcItem(ArcAppTest::GetAppId(app));
       ASSERT_NE(nullptr, app_item);
       const float scale = ui::GetScaleForScaleFactor(scale_factor);
       app_item->icon().GetRepresentation(scale);
     }
   }
 
   // Process pending tasks.
   content::BrowserThread::GetBlockingPool()->FlushForTesting();
   base::RunLoop().RunUntilIdle();
   // Normally just one call to RunUntilIdle() suffices to make sure
   // all RequestAppIcon() calls are delivered, but on slower machines
   // (especially when running under Valgrind), they might not get
   // delivered on time. Wait for the remaining tasks individually.
   const size_t expected_size = scale_factors.size() * fake_apps().size();
-  while (app_instance()->icon_requests().size() < expected_size) {
-    app_instance()->WaitForIncomingMethodCall();
-  }
 
   // At this moment we should receive all requests for icon loading.
   const ScopedVector<arc::FakeAppInstance::IconRequest>& icon_requests =
       app_instance()->icon_requests();
   EXPECT_EQ(expected_size, icon_requests.size());
   std::map<std::string, uint32_t> app_masks;
   for (size_t i = 0; i < icon_requests.size(); ++i) {
     const arc::FakeAppInstance::IconRequest* icon_request = icon_requests[i];
     const std::string id = ArcAppListPrefs::GetAppId(
         icon_request->package_name(), icon_request->activity());
@@ skipping 10 matching lines @@
     const std::string id = ArcAppTest::GetAppId(app);
     ASSERT_NE(app_masks.find(id), app_masks.end());
     EXPECT_EQ(app_masks[id], expected_mask);
   }
 }
 
 TEST_F(ArcAppModelBuilderTest, RequestShortcutIcons) {
   // Make sure we are on UI thread.
   ASSERT_TRUE(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
-  bridge_service()->SetReady();
   const arc::mojom::ShortcutInfo& shortcut = fake_shortcuts()[0];
   app_instance()->SendInstallShortcut(shortcut);
 
   ArcAppListPrefs* prefs = ArcAppListPrefs::Get(profile_.get());
   ASSERT_NE(nullptr, prefs);
 
   // Validate that no icon exists at the beginning and request icon for
   // each supported scale factor. This will start asynchronous loading.
   uint32_t expected_mask = 0;
   ArcAppItem* app_item = FindArcItem(ArcAppTest::GetAppId(shortcut));
@@ skipping 39 matching lines @@
     const base::FilePath icon_path =
         prefs->GetIconPath(ArcAppTest::GetAppId(shortcut), scale_factor);
     EXPECT_EQ(true, base::PathExists(icon_path));
   }
 }
 
 TEST_F(ArcAppModelBuilderTest, InstallIcon) {
   // Make sure we are on UI thread.
   ASSERT_TRUE(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
-  bridge_service()->SetReady();
   app_instance()->RefreshAppList();
   app_instance()->SendRefreshAppList(std::vector<arc::mojom::AppInfo>(
       fake_apps().begin(), fake_apps().begin() + 1));
   const arc::mojom::AppInfo& app = fake_apps()[0];
 
   ArcAppListPrefs* prefs = ArcAppListPrefs::Get(profile_.get());
   ASSERT_NE(nullptr, prefs);
 
   const ui::ScaleFactor scale_factor = ui::GetSupportedScaleFactors()[0];
   const float scale = ui::GetScaleForScaleFactor(scale_factor);
@@ skipping 30 matching lines @@
   std::string icon_data;
   // Read the file from disk and compare with reference data.
   EXPECT_EQ(true, base::ReadFileToString(icon_path, &icon_data));
   ASSERT_EQ(icon_data, png_data);
 }
 
 TEST_F(ArcAppModelBuilderTest, RemoveAppCleanUpFolder) {
   // Make sure we are on UI thread.
   ASSERT_TRUE(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
-  bridge_service()->SetReady();
   app_instance()->RefreshAppList();
   app_instance()->SendRefreshAppList(std::vector<arc::mojom::AppInfo>(
       fake_apps().begin(), fake_apps().begin() + 1));
   const arc::mojom::AppInfo& app = fake_apps()[0];
 
   ArcAppListPrefs* prefs = ArcAppListPrefs::Get(profile_.get());
   ASSERT_NE(nullptr, prefs);
 
   const std::string app_id = ArcAppTest::GetAppId(app);
   const base::FilePath app_path = prefs->GetAppPath(app_id);
@@ skipping 17 matching lines @@
   app_instance()->SendRefreshAppList(std::vector<arc::mojom::AppInfo>());
   content::BrowserThread::GetBlockingPool()->FlushForTesting();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(true, !base::PathExists(app_path));
 }
 
 TEST_F(ArcAppModelBuilderTest, LastLaunchTime) {
   // Make sure we are on UI thread.
   ASSERT_TRUE(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
-  bridge_service()->SetReady();
   app_instance()->RefreshAppList();
   app_instance()->SendRefreshAppList(std::vector<arc::mojom::AppInfo>(
       fake_apps().begin(), fake_apps().begin() + 2));
   const arc::mojom::AppInfo& app1 = fake_apps()[0];
   const arc::mojom::AppInfo& app2 = fake_apps()[1];
   const std::string id1 = ArcAppTest::GetAppId(app1);
   const std::string id2 = ArcAppTest::GetAppId(app2);
 
   ArcAppListPrefs* prefs = ArcAppListPrefs::Get(profile_.get());
   ASSERT_NE(nullptr, prefs);
@@ skipping 26 matching lines @@
   ASSERT_GE(time_after, app_info->last_launch_time);
 }
 
 TEST_F(ArcAppModelBuilderTest, IconLoader) {
   // Validating decoded content does not fit well for unit tests.
   ArcAppIcon::DisableSafeDecodingForTesting();
 
   const arc::mojom::AppInfo& app = fake_apps()[0];
   const std::string app_id = ArcAppTest::GetAppId(app);
 
-  bridge_service()->SetReady();
+  ArcAppListPrefs* prefs = ArcAppListPrefs::Get(profile_.get());
+  ASSERT_NE(nullptr, prefs);
+
   app_instance()->RefreshAppList();
   app_instance()->SendRefreshAppList(std::vector<arc::mojom::AppInfo>(
       fake_apps().begin(), fake_apps().begin() + 1));
 
   FakeAppIconLoaderDelegate delegate;
   ArcAppIconLoader icon_loader(profile(),
                                app_list::kListIconSize,
                                &delegate);
   EXPECT_EQ(0UL, delegate.update_image_cnt());
   icon_loader.FetchImage(app_id);
@@ skipping 36 matching lines @@
   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);
   EXPECT_FALSE(launcher1.app_launched());
   EXPECT_TRUE(prefs->HasObserver(&launcher1));
 
-  bridge_service()->SetReady();
-
   ArcAppLauncher launcher3(profile(), id3, true);
   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());
-  app_instance()->WaitForIncomingMethodCall();
   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);
   EXPECT_TRUE(launcher2.app_launched());
-  app_instance()->WaitForIncomingMethodCall();
   EXPECT_FALSE(prefs->HasObserver(&launcher2));
   ASSERT_EQ(2u, app_instance()->launch_requests().size());
   EXPECT_TRUE(app_instance()->launch_requests()[1]->IsForApp(app2));
 }