[Merge M56] Fix import legacy, pref based pins.

chrome/browser/ui/ash/launcher/chrome_launcher_controller_impl_unittest.cc

 // Copyright 2013 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 "chrome/browser/ui/ash/launcher/chrome_launcher_controller_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <map>
@@ skipping 11 matching lines @@
 #include "ash/common/wm/maximize_mode/maximize_mode_controller.h"
 #include "ash/common/wm_shell.h"
 #include "ash/display/screen_orientation_controller_chromeos.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_helper.h"
 #include "ash/test/test_shell_delegate.h"
 #include "ash/wm/window_util.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
+#include "base/json/json_string_value_serializer.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/chromeos/arc/arc_support_host.h"
 #include "chrome/browser/chromeos/login/users/fake_chrome_user_manager.h"
 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
 #include "chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/browser/lifetime/scoped_keep_alive.h"
+#include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/browser/ui/app_list/app_list_syncable_service_factory.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_list_prefs.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/apps/chrome_app_delegate.h"
 #include "chrome/browser/ui/ash/chrome_launcher_prefs.h"
 #include "chrome/browser/ui/ash/launcher/app_window_launcher_controller.h"
 #include "chrome/browser/ui/ash/launcher/arc_app_deferred_launcher_controller.h"
 #include "chrome/browser/ui/ash/launcher/browser_status_monitor.h"
@@ skipping 17 matching lines @@
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/browser_with_test_window_test.h"
 #include "chrome/test/base/test_browser_window_aura.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chrome/test/base/testing_profile_manager.h"
 #include "chromeos/chromeos_switches.h"
 #include "components/arc/common/app.mojom.h"
 #include "components/arc/test/fake_app_instance.h"
 #include "components/exo/shell_surface.h"
+#include "components/prefs/pref_notifier_impl.h"
 #include "components/signin/core/account_id/account_id.h"
+#include "components/sync/model/attachments/attachment_service_proxy_for_test.h"
 #include "components/sync/model/fake_sync_change_processor.h"
 #include "components/sync/model/sync_error_factory_mock.h"
 #include "components/sync/protocol/sync.pb.h"
+#include "components/sync_preferences/pref_model_associator.h"
 #include "components/sync_preferences/testing_pref_service_syncable.h"
 #include "components/user_manager/fake_user_manager.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/test/test_utils.h"
 #include "content/public/test/web_contents_tester.h"
 #include "extensions/browser/app_window/app_window_contents.h"
 #include "extensions/browser/app_window/app_window_registry.h"
 #include "extensions/browser/app_window/native_app_window.h"
 #include "extensions/common/extension.h"
@@ skipping 241 matching lines @@
     // Wait until |extension_system| is signaled as started.
     base::RunLoop run_loop;
     extension_system->ready().Post(FROM_HERE, run_loop.QuitClosure());
     run_loop.Run();
 
     app_service_ =
         app_list::AppListSyncableServiceFactory::GetForProfile(profile());
     StartAppSyncService(syncer::SyncDataList());
 
     std::string error;
+    extension_chrome_ = Extension::Create(base::FilePath(), Manifest::UNPACKED,
+                                          manifest, Extension::NO_FLAGS,
+                                          extension_misc::kChromeAppId, &error);
     extension1_ = Extension::Create(base::FilePath(), Manifest::UNPACKED,
                                     manifest,
                                     Extension::NO_FLAGS,
                                     "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
                                     &error);
     extension2_ = Extension::Create(base::FilePath(), Manifest::UNPACKED,
                                     manifest,
                                     Extension::NO_FLAGS,
                                     "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
                                     &error);
@@ skipping 38 matching lines @@
                                     "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
                                     &error);
     extension8_ = Extension::Create(base::FilePath(), Manifest::UNPACKED,
                                     manifest,
                                     Extension::NO_FLAGS,
                                     "ffffffffffffffffffffffffffffffff",
                                     &error);
     arc_support_host_ = Extension::Create(base::FilePath(), Manifest::UNPACKED,
                                           manifest, Extension::NO_FLAGS,
                                           ArcSupportHost::kHostAppId, &error);
+    extension_service_->AddExtension(extension_chrome_.get());
   }
 
   // Creates a running V2 app (not pinned) of type |app_id|.
   virtual void CreateRunningV2App(const std::string& app_id) {
     DCHECK(!test_controller_);
     ash::ShelfID id =
         launcher_controller_->CreateAppShortcutLauncherItemWithType(
             ash::launcher::AppLauncherId(app_id), model_->item_count(),
             ash::TYPE_PLATFORM_APP);
     DCHECK(id);
@@ skipping 96 matching lines @@
   void StartAppSyncService(const syncer::SyncDataList& init_sync_list) {
     app_service_->MergeDataAndStartSyncing(
         syncer::APP_LIST, init_sync_list,
         base::MakeUnique<syncer::FakeSyncChangeProcessor>(),
         base::MakeUnique<syncer::SyncErrorFactoryMock>());
     EXPECT_EQ(init_sync_list.size(), app_service_->sync_items().size());
   }
 
   void StopAppSyncService() { app_service_->StopSyncing(syncer::APP_LIST); }
 
+  sync_preferences::PrefModelAssociator* GetPrefSyncService() {
+    sync_preferences::PrefServiceSyncable* pref_sync =
+        profile()->GetTestingPrefService();
+    sync_preferences::PrefModelAssociator* pref_sync_service =
+        reinterpret_cast<sync_preferences::PrefModelAssociator*>(
+            pref_sync->GetSyncableService(syncer::PREFERENCES));
+    return pref_sync_service;
+  }
+
+  void StartPrefSyncService(const syncer::SyncDataList& init_sync_list) {
+    syncer::SyncMergeResult r = GetPrefSyncService()->MergeDataAndStartSyncing(
+        syncer::PREFERENCES, init_sync_list,
+        base::MakeUnique<syncer::FakeSyncChangeProcessor>(),
+        base::MakeUnique<syncer::SyncErrorFactoryMock>());
+    EXPECT_FALSE(r.error().IsSet());
+  }
+
+  void StartPrefSyncServiceForPins(const base::ListValue& init_value) {
+    syncer::SyncDataList init_sync_list;
+    std::string serialized;
+    JSONStringValueSerializer json(&serialized);
+    json.Serialize(init_value);
+    sync_pb::EntitySpecifics one;
+    sync_pb::PreferenceSpecifics* pref_one = one.mutable_preference();
+    pref_one->set_name(prefs::kPinnedLauncherApps);
+    pref_one->set_value(serialized);
+    init_sync_list.push_back(syncer::SyncData::CreateRemoteData(
+        1, one, base::Time(), syncer::AttachmentIdList(),
+        syncer::AttachmentServiceProxyForTest::Create()));
+    StartPrefSyncService(init_sync_list);
+  }
+
+  void StopPrefSyncService() {
+    GetPrefSyncService()->StopSyncing(syncer::PREFERENCES);
+  }
+
   void SetAppIconLoader(std::unique_ptr<AppIconLoader> loader) {
     std::vector<std::unique_ptr<AppIconLoader>> loaders;
     loaders.push_back(std::move(loader));
     launcher_controller_->SetAppIconLoadersForTest(loaders);
   }
 
   void SetAppIconLoaders(std::unique_ptr<AppIconLoader> loader1,
                          std::unique_ptr<AppIconLoader> loader2) {
     std::vector<std::unique_ptr<AppIconLoader>> loaders;
     loaders.push_back(std::move(loader1));
@@ skipping 350 matching lines @@
                          appinfo.name, std::string());
   }
 
   void NotifyOnTaskOrientationLockRequested(int32_t task_id,
                                             OrientationLock lock) {
     ArcAppListPrefs* const prefs = arc_test_.arc_app_list_prefs();
     prefs->OnTaskOrientationLockRequested(task_id, lock);
   }
 
   // Needed for extension service & friends to work.
+  scoped_refptr<Extension> extension_chrome_;
   scoped_refptr<Extension> extension1_;
   scoped_refptr<Extension> extension2_;
   scoped_refptr<Extension> extension3_;
   scoped_refptr<Extension> extension4_;
   scoped_refptr<Extension> extension5_;
   scoped_refptr<Extension> extension6_;
   scoped_refptr<Extension> extension7_;
   scoped_refptr<Extension> extension8_;
   scoped_refptr<Extension> arc_support_host_;
 
@@ skipping 1729 matching lines @@
   sync_list.clear();
   InsertRemovePinChange(&sync_list, extension3_->id());
   InsertRemovePinChange(&sync_list, extension2_->id());
   SendPinChanges(sync_list, false);
   expected_launchers.clear();
   GetAppLaunchers(launcher_controller_.get(), &actual_launchers);
   EXPECT_EQ(expected_launchers, actual_launchers);
 }
 
 TEST_F(ChromeLauncherControllerImplTest, ImportLegacyPin) {
+  // Note extension3_ is actually Gmail app which is default pinned.
+  extension_service_->AddExtension(extension3_.get());
+  InitLauncherController();
+
+  // Default pins should contain Gmail. Pref is not syncing now.
+  EXPECT_EQ("AppList, Chrome, App3", GetPinnedAppStatus());
+
   extension_service_->AddExtension(extension2_.get());
-  extension_service_->AddExtension(extension3_.get());
-  extension_service_->AddExtension(extension4_.get());
+  EXPECT_EQ("AppList, Chrome, App3", GetPinnedAppStatus());
 
   // Initially pins are imported from legacy pref based model.
   base::ListValue value;
   InsertPrefValue(&value, 0, extension4_->id());
   InsertPrefValue(&value, 1, extension2_->id());
-  profile()->GetTestingPrefService()->SetManagedPref(prefs::kPinnedLauncherApps,
-                                                     value.DeepCopy());
+  InsertPrefValue(&value, 2, extension3_->id());
+  StartPrefSyncServiceForPins(value);
 
-  InitLauncherController();
+  // Imported pins contain App2. App2 should be added to pins now.
+  EXPECT_EQ("AppList, Chrome, App2, App3", GetPinnedAppStatus());
 
-  EXPECT_EQ("AppList, Chrome, App4, App2", GetPinnedAppStatus());
+  // extension4_ is in the pin list.
+  extension_service_->AddExtension(extension4_.get());
+  // extension5_ is not in the pin list.
+  extension_service_->AddExtension(extension5_.get());
+  EXPECT_EQ("AppList, Chrome, App4, App2, App3", GetPinnedAppStatus());
+
+  // Apply app sync, unpin one app and pin new one.
+  syncer::SyncChangeList sync_list;
+  InsertAddPinChange(&sync_list, -1, extension3_->id());
+  InsertAddPinChange(&sync_list, 3, extension5_->id());
+  SendPinChanges(sync_list, false);
+  EXPECT_EQ("AppList, Chrome, App4, App2, App5", GetPinnedAppStatus());
 
   // At this point changing old pref based model does not affect pin model.
-  InsertPrefValue(&value, 2, extension3_->id());
-  profile()->GetTestingPrefService()->SetManagedPref(prefs::kPinnedLauncherApps,
-                                                     value.DeepCopy());
-  EXPECT_EQ("AppList, Chrome, App4, App2", GetPinnedAppStatus());
+  InsertPrefValue(&value, 3, extension5_->id());
+  StopPrefSyncService();
+  StartPrefSyncServiceForPins(value);
+  EXPECT_EQ("AppList, Chrome, App4, App2, App5", GetPinnedAppStatus());
+
+  // Next Chrome start should preserve pins.
   RecreateChromeLauncher();
-  EXPECT_EQ("AppList, Chrome, App4, App2", GetPinnedAppStatus());
+  StopPrefSyncService();
+  StartPrefSyncService(syncer::SyncDataList());
+  EXPECT_EQ("AppList, Chrome, App4, App2, App5", GetPinnedAppStatus());
 }
 
 TEST_F(ChromeLauncherControllerImplTest, PendingInsertionOrder) {
   extension_service_->AddExtension(extension1_.get());
   extension_service_->AddExtension(extension3_.get());
 
   InitLauncherController();
 
   syncer::SyncChangeList sync_list;
   InsertAddPinChange(&sync_list, 0, extension1_->id());
@@ skipping 890 matching lines @@
   EXPECT_EQ(AppListControllerDelegate::PIN_FIXED,
             GetPinnableForAppID(app_id, profile()));
 }
 
 TEST_F(ChromeLauncherControllerImplWithArcTest, ArcManaged) {
   extension_service_->AddExtension(arc_support_host_.get());
   // Test enables Arc, so turn it off for initial values.
   EnableArc(false);
 
   InitLauncherController();
+
   arc::ArcAuthService::SetShelfDelegateForTesting(launcher_controller_.get());
 
+  // To prevent import legacy pins each time.
+  // Initially pins are imported from legacy pref based model.
+  StartPrefSyncService(syncer::SyncDataList());
+
   // Initial run, Arc is not managed and disabled, Play Store pin should be
   // available.
   ValidateArcState(false, false, arc::ArcAuthService::State::STOPPED,
                    "AppList, Chrome, Play Store");
 
   // Arc is managed and enabled, Play Store pin should be available.
   // Note: SHOWING_TERMS_OF_SERVICE here means that opt-in flow starts.
   profile()->GetTestingPrefService()->SetManagedPref(
       prefs::kArcEnabled, new base::FundamentalValue(true));
   base::RunLoop().RunUntilIdle();
@@ skipping 449 matching lines @@
 
   // Pinned state should not change.
   EXPECT_EQ("AppList, Chrome, App1, App2", GetPinnedAppStatus());
   launcher_controller_->UnpinAppWithID(extension2_->id());
   EXPECT_EQ("AppList, Chrome, App1", GetPinnedAppStatus());
 
   // Resume syncing and sync information overrides local copy.
   StartAppSyncService(copy_sync_list);
   EXPECT_EQ("AppList, Chrome, App1, App2", GetPinnedAppStatus());
 }