Apps&Extensions for Supervised Users: send permission request on outdated re-enables

chrome/browser/extensions/extension_service_unittest.cc

 // Copyright (c) 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 <algorithm>
 #include <set>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/basictypes.h"
@@ skipping 7039 matching lines @@
   PackCRXAndUpdateExtension(id, path, pem_path, ENABLED);
 
   // The extension should still be there and enabled.
   extension = registry()->enabled_extensions().GetByID(id);
   ASSERT_TRUE(extension);
   // The version should have changed.
   EXPECT_NE(extension->VersionString(), old_version);
 }
 
 TEST_F(ExtensionServiceTest, SupervisedUser_UpdateWithPermissionIncrease) {
+  // This is the update URL specified in the test extension. Setting it here is
+  // necessary to make the extension considered syncable.
+  base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
+      switches::kAppsGalleryUpdateURL,
+      "http://localhost/autoupdate/updates.xml");
+
   ExtensionServiceInitParams params = CreateDefaultInitParams();
   params.profile_is_supervised = true;
   InitializeExtensionService(params);
+  InitializeExtensionSyncService();
+  extension_sync_service()->MergeDataAndStartSyncing(
+      syncer::EXTENSIONS,
+      syncer::SyncDataList(),
+      scoped_ptr<syncer::SyncChangeProcessor>(
+          new syncer::FakeSyncChangeProcessor),
+      scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
   SupervisedUserService* supervised_user_service =
       SupervisedUserServiceFactory::GetForProfile(profile());
   ScopedSupervisedUserServiceDelegate delegate(supervised_user_service);
   supervised_user_service->Init();
   MockPermissionRequestCreator* creator = new MockPermissionRequestCreator;
   supervised_user_service->AddPermissionRequestCreator(
       make_scoped_ptr(creator));
 
+  const std::string version1("1");
+  const std::string version2("2");
+  const std::string version3("3");
+
   base::FilePath base_path = data_dir().AppendASCII("permissions_increase");
   base::FilePath pem_path = base_path.AppendASCII("permissions.pem");
 
   base::FilePath path = base_path.AppendASCII("v1");
   const Extension* extension =
       PackAndInstallCRX(path, pem_path, INSTALL_NEW,
                         Extension::WAS_INSTALLED_BY_CUSTODIAN);
   // The extension must now be installed and enabled.
   ASSERT_TRUE(extension);
   ASSERT_TRUE(registry()->enabled_extensions().Contains(extension->id()));
+  ASSERT_EQ(version1, extension->VersionString());
 
   // 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 with increased permissions.
   EXPECT_CALL(*creator,
-              CreateExtensionUpdateRequest(id + ":2", testing::_));
+              CreateExtensionUpdateRequest(id + ":" + version2, testing::_));
   path = base_path.AppendASCII("v2");
   PackCRXAndUpdateExtension(id, path, pem_path, DISABLED);
 
   // The extension should still be there, but disabled.
   EXPECT_FALSE(registry()->enabled_extensions().Contains(id));
   extension = registry()->disabled_extensions().GetByID(id);
   ASSERT_TRUE(extension);
   // The version should have changed.
-  EXPECT_NE(extension->VersionString(), old_version);
+  EXPECT_EQ(version2, extension->VersionString());
+
+  // Create a sync update to re-enable the extension, but set the old version.
+  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(version1);
+  {
+    // Attempting to re-enable an old version should result in a permission
+    // request for the current version.
+    EXPECT_CALL(*creator,
+                CreateExtensionUpdateRequest(id + ":" + version2, testing::_));
+
+    syncer::SyncData sync_data =
+        syncer::SyncData::CreateLocalData(id, "Name", specifics);
+    syncer::SyncChange sync_change(FROM_HERE,
+                                   syncer::SyncChange::ACTION_UPDATE,
+                                   sync_data);
+    syncer::SyncChangeList change_list(1, sync_change);
+    extension_sync_service()->ProcessSyncChanges(FROM_HERE, change_list);
+    // The re-enable should be ignored, since the version doesn't match.
+    EXPECT_FALSE(registry()->enabled_extensions().Contains(id));
+  }
+
+  // Again, but now set a newer version than what is installed.
+  ext_specifics->set_version(version3);
+  {
+    syncer::SyncData sync_data =
+        syncer::SyncData::CreateLocalData(id, "Name", specifics);
+    syncer::SyncChange sync_change(FROM_HERE,
+                                   syncer::SyncChange::ACTION_UPDATE,
+                                   sync_data);
+    syncer::SyncChangeList change_list(1, sync_change);
+    extension_sync_service()->ProcessSyncChanges(FROM_HERE, change_list);
+    // The re-enable should be delayed until the extension is updated to the
+    // matching version.
+    EXPECT_FALSE(registry()->enabled_extensions().Contains(id));
+  }
+
+  // Update to the matching version. Now the extension should get enabled.
+  path = base_path.AppendASCII("v3");
+  PackCRXAndUpdateExtension(id, path, pem_path, ENABLED);
 }
 
 TEST_F(ExtensionServiceTest,
        SupervisedUser_SyncUninstallByCustodianSkipsPolicy) {
   InitializeEmptyExtensionService();
   InitializeExtensionSyncService();
   extension_sync_service()->MergeDataAndStartSyncing(
       syncer::EXTENSIONS,
       syncer::SyncDataList(),
       scoped_ptr<syncer::SyncChangeProcessor>(
@@ skipping 962 matching lines @@
 
   service()->Observe(chrome::NOTIFICATION_PROFILE_DESTRUCTION_STARTED,
                      content::Source<Profile>(profile()),
                      content::NotificationService::NoDetails());
   EXPECT_EQ(UnloadedExtensionInfo::REASON_PROFILE_SHUTDOWN, unloaded_reason_);
   EXPECT_EQ(0u, registry()->enabled_extensions().size());
   EXPECT_EQ(0u, registry()->disabled_extensions().size());
   EXPECT_EQ(0u, registry()->terminated_extensions().size());
   EXPECT_EQ(0u, registry()->blacklisted_extensions().size());
 }