arc: Fix duplicate icons in app launcher in case of crash.

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>
 #include <string>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/task_runner_util.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/arc/arc_support_host.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/policy/profile_policy_connector.h"
 #include "chrome/browser/policy/profile_policy_connector_factory.h"
 #include "chrome/browser/ui/app_list/app_list_test_util.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_icon.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_icon_loader.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_item.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_launcher.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_list_prefs.h"
+#include "chrome/browser/ui/app_list/arc/arc_app_list_prefs_factory.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_model_builder.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_test.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_utils.h"
 #include "chrome/browser/ui/app_list/arc/arc_default_app_list.h"
+#include "chrome/browser/ui/app_list/arc/arc_package_syncable_service_factory.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/arc/test/fake_arc_bridge_service.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest_constants.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/app_list/app_list_constants.h"
 #include "ui/app_list/app_list_model.h"
 #include "ui/gfx/geometry/safe_integer_conversions.h"
 #include "ui/gfx/image/image_skia.h"
 
 namespace {
 
 constexpr char kTestPackageName[] = "fake.package.name2";
 
 class FakeAppIconLoaderDelegate : public AppIconLoaderDelegate {
  public:
-  FakeAppIconLoaderDelegate() {}
-  ~FakeAppIconLoaderDelegate() override {}
+  FakeAppIconLoaderDelegate() = default;
+  ~FakeAppIconLoaderDelegate() override = default;
 
   void OnAppImageUpdated(const std::string& app_id,
                          const gfx::ImageSkia& image) override {
     app_id_ = app_id;
     image_ = image;
     ++update_image_cnt_;
   }
 
   size_t update_image_cnt() const { return update_image_cnt_; }
 
@@ skipping 18 matching lines @@
   do {
     content::BrowserThread::GetBlockingPool()->FlushForTesting();
     base::RunLoop().RunUntilIdle();
   } while (!base::PathExists(icon_path));
 }
 
 }  // namespace
 
 class ArcAppModelBuilderTest : public AppListTestBase {
  public:
-  ArcAppModelBuilderTest() {}
+  ArcAppModelBuilderTest() = default;
   ~ArcAppModelBuilderTest() override {
     // Release profile file in order to keep right sequence.
     profile_.reset();
   }
 
   void SetUp() override {
     AppListTestBase::SetUp();
     OnBeforeArcTestSetup();
     arc_test_.SetUp(profile_.get());
     CreateBuilder();
@@ skipping 51 matching lines @@
           break;
         }
       }
     }
     EXPECT_NE(nullptr, arc_item);
     return arc_item;
   }
 
   ArcAppItem* FindArcItem(const std::string& id) const {
     const size_t count = GetArcItemCount();
+    ArcAppItem* found_item = nullptr;
     for (size_t i = 0; i < count; ++i) {
       ArcAppItem* item = GetArcItem(i);
-      if (item && item->id() == id)
-        return item;
+      if (item && item->id() == id) {
+        DCHECK(!found_item);
+        found_item = item;
+      }
     }
-    return nullptr;
+    return found_item;
   }
 
   // Validate that prefs and model have right content.
   void ValidateHaveApps(const std::vector<arc::mojom::AppInfo> apps) {
     ValidateHaveAppsAndShortcuts(apps, std::vector<arc::mojom::ShortcutInfo>());
   }
 
   void ValidateHaveShortcuts(
       const std::vector<arc::mojom::ShortcutInfo> shortcuts) {
     ValidateHaveAppsAndShortcuts(std::vector<arc::mojom::AppInfo>(), shortcuts);
@@ skipping 170 matching lines @@
   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);
 };
 
 class ArcDefaulAppTest : public ArcAppModelBuilderTest {
  public:
-  ArcDefaulAppTest() {}
-  ~ArcDefaulAppTest() override {}
+  ArcDefaulAppTest() = default;
+  ~ArcDefaulAppTest() override = default;
 
  protected:
   // ArcAppModelBuilderTest:
   void OnBeforeArcTestSetup() override {
     ArcDefaultAppList::UseTestAppsDirectory();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ArcDefaulAppTest);
 };
 
 class ArcDefaulAppForManagedUserTest : public ArcDefaulAppTest {
  public:
-  ArcDefaulAppForManagedUserTest() {}
-  ~ArcDefaulAppForManagedUserTest() override {}
+  ArcDefaulAppForManagedUserTest() = default;
+  ~ArcDefaulAppForManagedUserTest() override = default;
 
  protected:
   // ArcAppModelBuilderTest:
   void OnBeforeArcTestSetup() override {
     ArcDefaulAppTest::OnBeforeArcTestSetup();
 
     policy::ProfilePolicyConnector* const connector =
         policy::ProfilePolicyConnectorFactory::GetForBrowserContext(
             profile());
     connector->OverrideIsManagedForTesting(true);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ArcDefaulAppForManagedUserTest);
 };
 
 class ArcPlayStoreAppTest : public ArcDefaulAppTest {
  public:
-  ArcPlayStoreAppTest() {}
-  ~ArcPlayStoreAppTest() override {}
+  ArcPlayStoreAppTest() = default;
+  ~ArcPlayStoreAppTest() override = default;
 
  protected:
   // ArcAppModelBuilderTest:
   void OnBeforeArcTestSetup() override {
     ArcDefaulAppTest::OnBeforeArcTestSetup();
 
     base::DictionaryValue manifest;
     manifest.SetString(extensions::manifest_keys::kName,
                        "Play Store");
     manifest.SetString(extensions::manifest_keys::kVersion, "1");
@@ skipping 11 matching lines @@
         extensions::ExtensionSystem::Get(profile_.get())->extension_service();
     extension_service->AddExtension(arc_support_host_.get());
   }
 
  private:
   scoped_refptr<extensions::Extension> arc_support_host_;
 
   DISALLOW_COPY_AND_ASSIGN(ArcPlayStoreAppTest);
 };
 
+class ArcAppModelBuilderRecreate : public ArcAppModelBuilderTest {
+ public:
+  ArcAppModelBuilderRecreate() = default;
+  ~ArcAppModelBuilderRecreate() override = default;
+
+ protected:
+  // ArcAppModelBuilderTest:
+  void OnBeforeArcTestSetup() override {
+    arc::ArcPackageSyncableServiceFactory::GetInstance()->SetTestingFactory(
+        profile_.get(), nullptr);
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ArcAppModelBuilderRecreate);
+};
+
 TEST_F(ArcAppModelBuilderTest, ArcPackagePref) {
   ValidateHavePackages(std::vector<arc::mojom::ArcPackageInfo>());
   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;
@@ skipping 467 matching lines @@
   base::Time time_before = base::Time::Now();
   arc::LaunchApp(profile(), id2);
   base::Time time_after = base::Time::Now();
 
   app_info = prefs->GetApp(id2);
   ASSERT_NE(nullptr, app_info.get());
   ASSERT_LE(time_before, app_info->last_launch_time);
   ASSERT_GE(time_after, app_info->last_launch_time);
 }
 
+// Validate that arc model contains expected elements on restart.
+TEST_F(ArcAppModelBuilderRecreate, AppModelRestart) {
+  // No apps on initial start.
+  ValidateHaveApps(std::vector<arc::mojom::AppInfo>());
+
+  // Send info about all fake apps except last.
+  std::vector<arc::mojom::AppInfo> apps1(fake_apps().begin(),
+                                         fake_apps().end() - 1);
+  app_instance()->RefreshAppList();
+  app_instance()->SendRefreshAppList(apps1);
+  // Model has refreshed apps.
+  ValidateHaveApps(apps1);
+  EXPECT_EQ(apps1.size(), GetArcItemCount());
+
+  // Simulate restart.
+  arc_test()->TearDown();
+  ResetBuilder();
+
+  ArcAppListPrefsFactory::GetInstance()->RecreateServiceInstanceForTesting(
+      profile_.get());
+  arc_test()->SetUp(profile_.get());
+  CreateBuilder();
+
+  // On restart new model contains last apps.
+  ValidateHaveApps(apps1);
+  EXPECT_EQ(apps1.size(), GetArcItemCount());
+
+  // Now refresh old apps with new one.
+  app_instance()->RefreshAppList();
+  app_instance()->SendRefreshAppList(fake_apps());
+  ValidateHaveApps(fake_apps());
+  EXPECT_EQ(fake_apps().size(), GetArcItemCount());
+}
+
 TEST_F(ArcPlayStoreAppTest, PlayStore) {
   // Make sure PlayStore is available.
   ASSERT_TRUE(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   ArcAppListPrefs* prefs = ArcAppListPrefs::Get(profile_.get());
   ASSERT_TRUE(prefs);
 
   std::unique_ptr<ArcAppListPrefs::AppInfo> app_info = prefs->GetApp(
       arc::kPlayStoreAppId);
   ASSERT_TRUE(app_info);
@@ skipping 221 matching lines @@
   const ArcAppListPrefs* const prefs = ArcAppListPrefs::Get(profile_.get());
   ASSERT_TRUE(prefs);
 
   // There is no default app for managed users except Play Store
   for (const auto& app : fake_default_apps()) {
     const std::string app_id = ArcAppTest::GetAppId(app);
     EXPECT_FALSE(prefs->IsRegistered(app_id));
     EXPECT_FALSE(prefs->GetApp(app_id));
   }
 }