Replace the WAS_INSTALLED_BY_CUSTODIAN creation flag with a pref

chrome/browser/extensions/extension_service_sync_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 <map>
 #include <memory>
 #include <string>
 #include <utility>
@@ skipping 50 matching lines @@
 using extensions::ExtensionPrefs;
 using extensions::ExtensionSyncData;
 using extensions::ExtensionSystem;
 using extensions::Manifest;
 using extensions::PermissionSet;
 using syncer::SyncChange;
 using syncer::SyncChangeList;
 
 namespace {
 
+const char autoupdate[] = "ogjcoiohnmldgjemafoockdghcjciccf";
 const char good0[] = "behllobkkfkfnphdnhnkndlbkcpglgmj";
 const char good2[] = "bjafgdebaacbbbecmhlhpofkepfkgcpa";
+const char good2048[] = "nmgjhmhbleinmjpbdhgajfjkbijcmgbh";
 const char good_crx[] = "ldnnhddmnhbkjipkidpdiheffobcpfmf";
 const char page_action[] = "obcimlgaoabeegjmmpldobjndiealpln";
+const char permissions_increase[] = "pgdpcfcocojkjfbgpiianjngphoopgmo";
 const char theme2_crx[] = "pjpgmfcmabopnnfonnhmdjglfpjjfkbf";
 
 SyncChangeList MakeSyncChangeList(const std::string& id,
                                   const sync_pb::EntitySpecifics& specifics,
                                   SyncChange::SyncChangeType change_type) {
   syncer::SyncData sync_data =
       syncer::SyncData::CreateLocalData(id, "Name", specifics);
   return SyncChangeList(1, SyncChange(FROM_HERE, change_type, sync_data));
 }
 
@@ skipping 220 matching lines @@
 
   // Sync starts up.
   extension_sync_service()->MergeDataAndStartSyncing(
       syncer::EXTENSIONS, syncer::SyncDataList(),
       base::WrapUnique(new syncer::FakeSyncChangeProcessor()),
       base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   // Then sync data arrives telling us to disable |good0|.
   ExtensionSyncData disable_good_crx(*extension, false,
                                      Extension::DISABLE_USER_ACTION, false,
-                                     false, ExtensionSyncData::BOOLEAN_UNSET);
+                                     false, ExtensionSyncData::BOOLEAN_UNSET,
+                                     false);
   SyncChangeList list(
       1, disable_good_crx.GetSyncChange(SyncChange::ACTION_UPDATE));
   extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
 
   ASSERT_FALSE(service()->IsExtensionEnabled(good0));
 }
 
 TEST_F(ExtensionServiceSyncTest, IgnoreSyncChangesWhenLocalStateIsMoreRecent) {
   // Start the extension service with three extensions already installed.
   base::FilePath source_install_dir =
@@ skipping 28 matching lines @@
   ASSERT_FALSE(service()->IsExtensionEnabled(good2));
 
   const Extension* extension0 = service()->GetExtensionById(good0, true);
   const Extension* extension2 = service()->GetExtensionById(good2, true);
   ASSERT_TRUE(extensions::sync_helper::IsSyncable(extension0));
   ASSERT_TRUE(extensions::sync_helper::IsSyncable(extension2));
 
   // Now sync data comes in that says to disable good0 and enable good2.
   ExtensionSyncData disable_good0(*extension0, false,
                                   Extension::DISABLE_USER_ACTION, false, false,
-                                  ExtensionSyncData::BOOLEAN_UNSET);
+                                  ExtensionSyncData::BOOLEAN_UNSET, false);
   ExtensionSyncData enable_good2(*extension2, true, Extension::DISABLE_NONE,
                                  false, false,
-                                 ExtensionSyncData::BOOLEAN_UNSET);
+                                 ExtensionSyncData::BOOLEAN_UNSET, false);
   syncer::SyncDataList sync_data;
   sync_data.push_back(disable_good0.GetSyncData());
   sync_data.push_back(enable_good2.GetSyncData());
   extension_sync_service()->MergeDataAndStartSyncing(
       syncer::EXTENSIONS, sync_data,
       base::WrapUnique(new syncer::FakeSyncChangeProcessor()),
       base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
   // Both sync changes should be ignored, since the local state was changed
   // before sync started, and so the local state is considered more recent.
@@ skipping 30 matching lines @@
 
   // Simulate various incoming sync changes, and make sure they don't result in
   // any outgoing changes.
 
   {
     const Extension* extension = service()->GetExtensionById(good0, true);
     ASSERT_TRUE(extension);
 
     // Disable the extension.
     ExtensionSyncData data(*extension, false, Extension::DISABLE_USER_ACTION,
-                           false, false, ExtensionSyncData::BOOLEAN_UNSET);
+                           false, false, ExtensionSyncData::BOOLEAN_UNSET,
+                           false);
     SyncChangeList list(1, data.GetSyncChange(SyncChange::ACTION_UPDATE));
 
     extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
 
     EXPECT_TRUE(processor->changes().empty());
   }
 
   {
     const Extension* extension = service()->GetExtensionById(good0, true);
     ASSERT_TRUE(extension);
 
     // Set incognito enabled to true.
     ExtensionSyncData data(*extension, false, Extension::DISABLE_NONE, true,
-                           false, ExtensionSyncData::BOOLEAN_UNSET);
+                           false, ExtensionSyncData::BOOLEAN_UNSET, false);
     SyncChangeList list(1, data.GetSyncChange(SyncChange::ACTION_UPDATE));
 
     extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
 
     EXPECT_TRUE(processor->changes().empty());
   }
 
   {
     const Extension* extension = service()->GetExtensionById(good0, true);
     ASSERT_TRUE(extension);
 
     // Add another disable reason.
     ExtensionSyncData data(*extension, false,
                            Extension::DISABLE_USER_ACTION |
                                Extension::DISABLE_PERMISSIONS_INCREASE,
-                           false, false, ExtensionSyncData::BOOLEAN_UNSET);
+                           false, false, ExtensionSyncData::BOOLEAN_UNSET,
+                           false);
     SyncChangeList list(1, data.GetSyncChange(SyncChange::ACTION_UPDATE));
 
     extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
 
     EXPECT_TRUE(processor->changes().empty());
   }
 
   {
     const Extension* extension = service()->GetExtensionById(good0, true);
     ASSERT_TRUE(extension);
 
     // Uninstall the extension.
     ExtensionSyncData data(*extension, false,
                            Extension::DISABLE_USER_ACTION |
                                Extension::DISABLE_PERMISSIONS_INCREASE,
-                           false, false, ExtensionSyncData::BOOLEAN_UNSET);
+                           false, false, ExtensionSyncData::BOOLEAN_UNSET,
+                           false);
     SyncChangeList list(1, data.GetSyncChange(SyncChange::ACTION_DELETE));
 
     extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
 
     EXPECT_TRUE(processor->changes().empty());
   }
 }
 
 TEST_F(ExtensionServiceSyncTest, GetSyncData) {
   InitializeEmptyExtensionService();
@@ skipping 1100 matching lines @@
     InitializeExtensionService(params);
     StartSyncing(syncer::EXTENSIONS);
 
     supervised_user_service()->SetDelegate(this);
     supervised_user_service()->Init();
   }
 
   std::string InstallPermissionsTestExtension() {
     const std::string version("1");
 
+    extensions::util::SetWasInstalledByCustodian(permissions_increase,
+                                                 profile());
     const Extension* extension =
-        PackAndInstallCRX(dir_path(version), pem_path(), INSTALL_NEW,
-                          Extension::WAS_INSTALLED_BY_CUSTODIAN);
+        PackAndInstallCRX(dir_path(version), pem_path(), INSTALL_NEW);
+
     // The extension must now be installed and enabled.
     EXPECT_TRUE(extension);
     EXPECT_TRUE(registry()->enabled_extensions().Contains(extension->id()));
     EXPECT_EQ(version, extension->VersionString());
 
     return extension->id();
   }
 
   void UpdatePermissionsTestExtension(const std::string& id,
                                       const std::string& version,
@@ skipping 49 matching lines @@
                void(const std::string& id,
                     const SupervisedUserService::SuccessCallback& callback));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockPermissionRequestCreator);
 };
 
 TEST_F(ExtensionServiceTestSupervised, InstallOnlyAllowedByCustodian) {
   InitServices(true /* profile_is_supervised */);
 
+  extensions::util::SetWasInstalledByCustodian(good2048, profile());
+
   base::FilePath path1 = data_dir().AppendASCII("good.crx");
   base::FilePath path2 = data_dir().AppendASCII("good2048.crx");
   const Extension* extensions[] = {
     InstallCRX(path1, INSTALL_FAILED),
-    InstallCRX(path2, INSTALL_NEW, Extension::WAS_INSTALLED_BY_CUSTODIAN)
+    InstallCRX(path2, INSTALL_NEW)
   };
 
   // Only the extension with the "installed by custodian" flag should have been
   // installed and enabled.
   EXPECT_FALSE(extensions[0]);
   ASSERT_TRUE(extensions[1]);
   EXPECT_TRUE(registry()->enabled_extensions().Contains(extensions[1]->id()));
 }
 
 TEST_F(ExtensionServiceTestSupervised, PreinstalledExtension) {
   InitServices(false /* profile_is_supervised */);
 
   // Install an extension.
   base::FilePath path = data_dir().AppendASCII("good.crx");
   const Extension* extension = InstallCRX(path, INSTALL_NEW);
   std::string id = extension->id();
 
   // Now make the profile supervised.
   profile()->AsTestingProfile()->SetSupervisedUserId(
       supervised_users::kChildAccountSUID);
 
   // The extension should not be enabled anymore.
   EXPECT_FALSE(registry()->enabled_extensions().Contains(id));
 }
 
+TEST_F(ExtensionServiceTestSupervised,
+       DelegatedAndPreinstalledExtensionIsSUFirst) {
+  InitServices(false /* profile_is_supervised */);
+
+  // Install an extension.
+  base::FilePath path = data_dir().AppendASCII("good.crx");
+  const Extension* extension = InstallCRX(path, INSTALL_NEW);
+  std::string id = extension->id();
+  const std::string version("1.0.0.0");
+  // It should be enabled.
+  EXPECT_TRUE(registry()->enabled_extensions().Contains(id));
+
+  // Now make the profile supervised.
+  profile()->AsTestingProfile()->SetSupervisedUserId(
+      supervised_users::kChildAccountSUID);
+
+  // It should not be enabled now (it is not loaded at all actually).
+  EXPECT_FALSE(registry()->enabled_extensions().Contains(id));
+
+  // Simulate data sync with the "was_installed_by_custodian" flag set to 1.
+  sync_pb::EntitySpecifics specifics;
+  sync_pb::ExtensionSpecifics* ext_specifics = specifics.mutable_extension();
+  ext_specifics->set_id(id);
+  ext_specifics->set_enabled(true);
+  ext_specifics->set_disable_reasons(Extension::DISABLE_NONE);
+  ext_specifics->set_installed_by_custodian(true);
+  ext_specifics->set_version(version);
+
+  SyncChangeList list =
+      MakeSyncChangeList(id, specifics, SyncChange::ACTION_UPDATE);
+
+  extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
+
+  // The extension should be enabled again.
+  const Extension* installed_extension =
+      registry()->enabled_extensions().GetByID(id);
+  ASSERT_TRUE(installed_extension);

[Marc Treib, 2016/06/17 08:56:54]

Since you don't need |installed_extension| afterwards, this can be an
EXPECT_TRUE, and you can just inline the registry lookup directly here.

[mamir, 2016/06/17 16:12:54]

Done.

+  EXPECT_TRUE(extensions::util::WasInstalledByCustodian(id, profile()));
+}
+
+TEST_F(ExtensionServiceTestSupervised,
+       DelegatedAndPreinstalledExtensionSyncFirst) {
+  InitServices(false /* profile_is_supervised */);
+
+  // Install an extension.
+  base::FilePath path = data_dir().AppendASCII("good.crx");
+  const Extension* extension = InstallCRX(path, INSTALL_NEW);
+  std::string id = extension->id();
+  const std::string version("1.0.0.0");
+
+  // It should be enabled.
+  EXPECT_TRUE(registry()->enabled_extensions().Contains(id));
+
+  // Simulate data sync with the "was_installed_by_custodian" flag set to 1.
+  sync_pb::EntitySpecifics specifics;
+  sync_pb::ExtensionSpecifics* ext_specifics = specifics.mutable_extension();
+  ext_specifics->set_id(id);
+  ext_specifics->set_enabled(true);
+  ext_specifics->set_disable_reasons(Extension::DISABLE_NONE);
+  ext_specifics->set_installed_by_custodian(true);
+  ext_specifics->set_version(version);
+
+  SyncChangeList list =
+      MakeSyncChangeList(id, specifics, SyncChange::ACTION_UPDATE);
+
+  extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
+
+  // Now make the profile supervised.
+  profile()->AsTestingProfile()->SetSupervisedUserId(
+      supervised_users::kChildAccountSUID);
+
+  // The extension should be enabled.
+  const Extension* installed_extension =
+      registry()->enabled_extensions().GetByID(id);
+  ASSERT_TRUE(installed_extension);

[Marc Treib, 2016/06/17 08:56:54]

Same here.

[mamir, 2016/06/17 16:12:54]

Done.

+  EXPECT_TRUE(extensions::util::WasInstalledByCustodian(id, profile()));
+}
+
 TEST_F(ExtensionServiceTestSupervised, UpdateWithoutPermissionIncrease) {
   InitServices(true /* profile_is_supervised */);
 
   base::FilePath base_path = data_dir().AppendASCII("autoupdate");
   base::FilePath pem_path = base_path.AppendASCII("key.pem");
 
+  extensions::util::SetWasInstalledByCustodian(autoupdate, profile());
   const Extension* extension =
-      PackAndInstallCRX(base_path.AppendASCII("v1"), pem_path, INSTALL_NEW,
-                        Extension::WAS_INSTALLED_BY_CUSTODIAN);
+      PackAndInstallCRX(base_path.AppendASCII("v1"), pem_path, INSTALL_NEW);
+
   // The extension must now be installed and enabled.
   ASSERT_TRUE(extension);
   ASSERT_TRUE(registry()->enabled_extensions().Contains(extension->id()));
 
   // Save the id, as the extension object will be destroyed during updating.
   std::string id = extension->id();
 
   std::string old_version = extension->VersionString();
 
   // Update to a new version.
@@ skipping 159 matching lines @@
   UpdatePermissionsTestExtension(id, version3, ENABLED);
 }
 
 TEST_F(ExtensionServiceSyncTest, SyncUninstallByCustodianSkipsPolicy) {
   InitializeEmptyExtensionService();
   extension_sync_service()->MergeDataAndStartSyncing(
       syncer::EXTENSIONS, syncer::SyncDataList(),
       base::WrapUnique(new syncer::FakeSyncChangeProcessor()),
       base::WrapUnique(new syncer::SyncErrorFactoryMock()));
 
+  extensions::util::SetWasInstalledByCustodian(good2048, profile());
   // Install two extensions.
   base::FilePath path1 = data_dir().AppendASCII("good.crx");
   base::FilePath path2 = data_dir().AppendASCII("good2048.crx");
   const Extension* extensions[] = {
     InstallCRX(path1, INSTALL_NEW),
-    InstallCRX(path2, INSTALL_NEW, Extension::WAS_INSTALLED_BY_CUSTODIAN)
+    InstallCRX(path2, INSTALL_NEW)
   };
 
   // Add a policy provider that will disallow any changes.
   extensions::TestManagementPolicyProvider provider(
       extensions::TestManagementPolicyProvider::PROHIBIT_MODIFY_STATUS);
   ExtensionSystem::Get(
       browser_context())->management_policy()->RegisterProvider(&provider);
 
   // Create a sync deletion for each extension.
   SyncChangeList list;
   for (size_t i = 0; i < arraysize(extensions); i++) {
     const std::string& id = extensions[i]->id();
     sync_pb::EntitySpecifics specifics;
     sync_pb::ExtensionSpecifics* ext_specifics = specifics.mutable_extension();
     ext_specifics->set_id(id);
     ext_specifics->set_version("1.0");
     ext_specifics->set_installed_by_custodian(
-        extensions[i]->was_installed_by_custodian());
+        extensions::util::WasInstalledByCustodian(id, profile()));
+
     syncer::SyncData sync_data =
         syncer::SyncData::CreateLocalData(id, "Name", specifics);
     list.push_back(SyncChange(FROM_HERE, SyncChange::ACTION_DELETE, sync_data));
   }
 
   // Save the extension ids, as uninstalling destroys the Extension instance.
   std::string extension_ids[] = {
     extensions[0]->id(),
     extensions[1]->id()
   };
@@ skipping 145 matching lines @@
         break;
       }
     }
   }
   EXPECT_TRUE(found_delete);
 
   // Make sure there is one extension, and there are no more apps.
   EXPECT_EQ(1u, extensions_processor.data().size());
   EXPECT_TRUE(apps_processor.data().empty());
 }