Supervised users: Re-check ManagementPolicy when ProfileIsSupervised changes.

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 117 matching lines @@
 #include "sync/protocol/app_specifics.pb.h"
 #include "sync/protocol/extension_specifics.pb.h"
 #include "sync/protocol/sync.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "url/gurl.h"
 
 #if defined(ENABLE_SUPERVISED_USERS)
 #include "chrome/browser/supervised_user/permission_request_creator.h"
+#include "chrome/browser/supervised_user/supervised_user_constants.h"
 #include "chrome/browser/supervised_user/supervised_user_service.h"
 #include "chrome/browser/supervised_user/supervised_user_service_factory.h"
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/login/users/scoped_test_user_manager.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/device_settings_service.h"
 #endif
 
@@ skipping 6474 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_EQ(Manifest::INTERNAL, info->install_source());
   // TODO(akalin): Figure out a way to test |info.ShouldAllowInstall()|.
 }
 
 #if defined(ENABLE_SUPERVISED_USERS)
+class StubSupervisedUserServiceDelegate
+    : public SupervisedUserService::Delegate {
+ public:
+  explicit StubSupervisedUserServiceDelegate(SupervisedUserService* service)
+      : service_(service) {
+    service_->SetDelegate(this);
+  }
+  ~StubSupervisedUserServiceDelegate() override {
+    service_->SetDelegate(nullptr);
+  }
+
+  // This prevents the legacy supervised user init code from running.
+  bool SetActive(bool active) override { return true; }
+
+ private:
+  SupervisedUserService* service_;
+};
+
 class MockPermissionRequestCreator : public PermissionRequestCreator {
  public:
   MockPermissionRequestCreator() {}
   ~MockPermissionRequestCreator() override {}
 
   bool IsEnabled() const override { return true; }
 
   void CreateURLAccessRequest(const GURL& url_requested,
                               const SuccessCallback& callback) override {
     FAIL();
   }
 
   MOCK_METHOD2(CreateExtensionUpdateRequest,
                void(const std::string& id,
                     const SupervisedUserService::SuccessCallback& callback));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockPermissionRequestCreator);
 };
 
 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);
+  StubSupervisedUserServiceDelegate delegate(supervised_user_service);
+  supervised_user_service->Init();
 
   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_PreinstalledExtension) {
+  ExtensionServiceInitParams params = CreateDefaultInitParams();
+  // Do *not* set the profile to supervised here!
+  InitializeExtensionService(params);
+
+  SupervisedUserService* supervised_user_service =
+      SupervisedUserServiceFactory::GetForProfile(profile());
+  StubSupervisedUserServiceDelegate delegate(supervised_user_service);
+  supervised_user_service->Init();
+
+  // 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);
+  // Also set the corresponding pref, because that's what the
+  // SupervisedUserService watches.
+  profile()->GetPrefs()->SetString(prefs::kSupervisedUserId,
+                                   supervised_users::kChildAccountSUID);
+
+  // The extension should not be enabled anymore.
+  EXPECT_FALSE(registry()->enabled_extensions().Contains(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);
+  StubSupervisedUserServiceDelegate delegate(supervised_user_service);
+  supervised_user_service->Init();
 
   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);
@@ skipping 15 matching lines @@
   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);
+  StubSupervisedUserServiceDelegate delegate(supervised_user_service);
+  supervised_user_service->Init();
   MockPermissionRequestCreator* creator = new MockPermissionRequestCreator;
   supervised_user_service->AddPermissionRequestCreator(
       make_scoped_ptr(creator));
 
   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,
@@ skipping 994 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());
 }