Add tests for Extension installation/update for supervised users.

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 41 matching lines @@
 #include "chrome/browser/extensions/fake_safe_browsing_database_manager.h"
 #include "chrome/browser/extensions/installed_loader.h"
 #include "chrome/browser/extensions/pack_extension_job.h"
 #include "chrome/browser/extensions/pending_extension_info.h"
 #include "chrome/browser/extensions/pending_extension_manager.h"
 #include "chrome/browser/extensions/test_blacklist.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/extensions/updater/extension_updater.h"
 #include "chrome/browser/prefs/pref_service_syncable.h"
+#include "chrome/browser/supervised_user/supervised_user_service.h"
+#include "chrome/browser/supervised_user/supervised_user_service_factory.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/api/plugins/plugins_handler.h"
 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
 #include "chrome/common/extensions/manifest_handlers/content_scripts_handler.h"
 #include "chrome/common/extensions/manifest_url_handler.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
@@ skipping 665 matching lines @@
     loaded_.clear();
     ExtensionErrorReporter::GetInstance()->ClearErrors();
     return extension;
   }
 
   enum UpdateState {
     FAILED_SILENTLY,
     FAILED,
     UPDATED,
     INSTALLED,
+    DISABLED,
     ENABLED
   };
 
   void BlackListWebGL() {
     static const std::string json_blacklist =
       "{\n"
       "  \"name\": \"gpu blacklist\",\n"
       "  \"version\": \"1.0\",\n"
       "  \"entries\": [\n"
       "    {\n"
@@ skipping 10 matching lines @@
   // Helper method to set up a WindowedNotificationObserver to wait for a
   // specific CrxInstaller to finish if we don't know the value of the
   // |installer| yet.
   static bool IsCrxInstallerDone(extensions::CrxInstaller** installer,
                                  const content::NotificationSource& source,
                                  const content::NotificationDetails& details) {
     return content::Source<extensions::CrxInstaller>(source).ptr() ==
            *installer;
   }
 
+  void PackCRXAndUpdateExtension(const std::string& id,
+                                 const base::FilePath& dir_path,
+                                 const base::FilePath& pem_path,
+                                 UpdateState expected_state) {
+    base::ScopedTempDir temp_dir;
+    EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
+    base::FilePath crx_path = temp_dir.path().AppendASCII("temp.crx");
+
+    PackCRX(dir_path, pem_path, crx_path);
+    UpdateExtension(id, crx_path, expected_state);
+  }
+
   void UpdateExtension(const std::string& id,
                        const base::FilePath& in_path,
                        UpdateState expected_state) {
     ASSERT_TRUE(base::PathExists(in_path));
 
     // We need to copy this to a temporary location because Update() will delete
     // it.
     base::FilePath path = temp_dir().path();
     path = path.Append(in_path.BaseName());
     ASSERT_TRUE(base::CopyFile(in_path, path));
@@ skipping 5310 matching lines @@
   const extensions::PendingExtensionInfo* info;
   EXPECT_TRUE(
       (info = service()->pending_extension_manager()->GetById(good_crx)));
   EXPECT_EQ(ext_specifics->update_url(), info->update_url().spec());
   EXPECT_TRUE(info->is_from_sync());
   EXPECT_TRUE(info->install_silently());
   EXPECT_EQ(Manifest::INTERNAL, info->install_source());
   // TODO(akalin): Figure out a way to test |info.ShouldAllowInstall()|.
 }
 
-TEST_F(ExtensionServiceTest, SyncUninstallForSupervisedUser) {
+TEST_F(ExtensionServiceTest, SupervisedUser_InstallOnlyAllowedByCustodian) {
+  ExtensionServiceInitParams params = CreateDefaultInitParams();
+  params.profile_is_supervised = true;
+  InitializeExtensionService(params);
+
+  SupervisedUserService* supervised_user_service =
+      SupervisedUserServiceFactory::GetForProfile(profile());
+  GetManagementPolicy()->RegisterProvider(supervised_user_service);
+
+  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)
+  };
+
+  // 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(ExtensionServiceTest, SupervisedUser_UpdateWithoutPermissionIncrease) {
+  ExtensionServiceInitParams params = CreateDefaultInitParams();
+  params.profile_is_supervised = true;
+  InitializeExtensionService(params);
+
+  SupervisedUserService* supervised_user_service =
+      SupervisedUserServiceFactory::GetForProfile(profile());
+  GetManagementPolicy()->RegisterProvider(supervised_user_service);
+
+  base::FilePath base_path = data_dir().AppendASCII("autoupdate");
+  base::FilePath pem_path = base_path.AppendASCII("key.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()));
+
+  // 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.
+  path = base_path.AppendASCII("v2");
+  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) {
+  ExtensionServiceInitParams params = CreateDefaultInitParams();
+  params.profile_is_supervised = true;
+  InitializeExtensionService(params);
+
+  SupervisedUserService* supervised_user_service =
+      SupervisedUserServiceFactory::GetForProfile(profile());
+  GetManagementPolicy()->RegisterProvider(supervised_user_service);
+
+  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()));
+
+  // 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.
+  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);
+}
+
+TEST_F(ExtensionServiceTest,
+       SupervisedUser_SyncUninstallByCustodianSkipsPolicy) {
   InitializeEmptyExtensionService();
   InitializeExtensionSyncService();
   extension_sync_service()->MergeDataAndStartSyncing(
       syncer::EXTENSIONS,
       syncer::SyncDataList(),
       scoped_ptr<syncer::SyncChangeProcessor>(
           new syncer::FakeSyncChangeProcessor),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
   // Install two extensions.
   base::FilePath path1 = data_dir().AppendASCII("good.crx");
   base::FilePath path2 = data_dir().AppendASCII("good2048.crx");
-  const Extension* extensions[2] = {
+  const Extension* extensions[] = {
     InstallCRX(path1, INSTALL_NEW),
     InstallCRX(path2, INSTALL_NEW, Extension::WAS_INSTALLED_BY_CUSTODIAN)
   };
 
   // Add a policy provider that will disallow any changes.
   extensions::TestManagementPolicyProvider provider(
       extensions::TestManagementPolicyProvider::PROHIBIT_MODIFY_STATUS);
   GetManagementPolicy()->RegisterProvider(&provider);
 
   // Create a sync deletion for each extension.
   syncer::SyncChangeList change_list;
-  for (int i = 0; i < 2; i++) {
+  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());
     syncer::SyncData sync_data =
         syncer::SyncData::CreateLocalData(id, "Name", specifics);
     change_list.push_back(syncer::SyncChange(FROM_HERE,
                                              syncer::SyncChange::ACTION_DELETE,
                                              sync_data));
   }
 
   // Save the extension ids, as uninstalling destroys the Extension instance.
-  std::string extension_ids[2] = {
+  std::string extension_ids[] = {
     extensions[0]->id(),
     extensions[1]->id()
   };
 
   // Now apply the uninstallations.
   extension_sync_service()->ProcessSyncChanges(FROM_HERE, change_list);
 
   // Uninstalling the extension without installed_by_custodian should have been
-  // blocked by policy.
-  EXPECT_TRUE(service()->GetExtensionById(extension_ids[0], true));
+  // blocked by policy, so it should still be there.
+  EXPECT_TRUE(registry()->enabled_extensions().Contains(extension_ids[0]));
 
   // But installed_by_custodian should result in bypassing the policy check.
-  EXPECT_FALSE(service()->GetExtensionById(extension_ids[1], true));
+  EXPECT_FALSE(
+      registry()->GenerateInstalledExtensionsSet()->Contains(extension_ids[1]));
 }
 
 TEST_F(ExtensionServiceTest, InstallPriorityExternalUpdateUrl) {
   InitializeEmptyExtensionService();
 
   base::FilePath path = data_dir().AppendASCII("good.crx");
   InstallCRX(path, INSTALL_NEW);
   ValidatePrefKeyCount(1u);
   ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
   ValidateIntegerPref(good_crx, "location", Manifest::INTERNAL);
@@ skipping 867 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());
 }