Supervised users: Slightly relax restrictions around extensions.

chrome/browser/supervised_user/supervised_user_service_unittest.cc

 // Copyright 2014 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 "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ skipping 409 matching lines @@
       : SupervisedUserServiceExtensionTestBase(false) {}
 };
 
 class SupervisedUserServiceExtensionTest
     : public SupervisedUserServiceExtensionTestBase {
  public:
   SupervisedUserServiceExtensionTest()
       : SupervisedUserServiceExtensionTestBase(true) {}
 };
 
-TEST_F(SupervisedUserServiceExtensionTestUnsupervised,
-       ExtensionManagementPolicyProvider) {
-  SupervisedUserService* supervised_user_service =
-      SupervisedUserServiceFactory::GetForProfile(profile_.get());
-  EXPECT_FALSE(profile_->IsSupervised());
-
-  scoped_refptr<extensions::Extension> extension = MakeExtension(false);
-  base::string16 error_1;
-  EXPECT_TRUE(supervised_user_service->UserMayLoad(extension.get(), &error_1));
-  EXPECT_EQ(base::string16(), error_1);
-
-  base::string16 error_2;
-  EXPECT_TRUE(
-      supervised_user_service->UserMayModifySettings(extension.get(),
-                                                     &error_2));
-  EXPECT_EQ(base::string16(), error_2);
-}
-
 TEST_F(SupervisedUserServiceExtensionTest, ExtensionManagementPolicyProvider) {
   SupervisedUserService* supervised_user_service =
       SupervisedUserServiceFactory::GetForProfile(profile_.get());
   ASSERT_TRUE(profile_->IsSupervised());
 
-  // Check that a supervised user can install a theme.
-  scoped_refptr<extensions::Extension> theme = MakeThemeExtension();
-  base::string16 error_1;
-  EXPECT_TRUE(supervised_user_service->UserMayLoad(theme.get(), &error_1));
-  EXPECT_TRUE(error_1.empty());
-  EXPECT_TRUE(
-      supervised_user_service->UserMayModifySettings(theme.get(), &error_1));
-  EXPECT_TRUE(error_1.empty());
+  // Check that a supervised user can install and uninstall a theme.
+  {
+    scoped_refptr<extensions::Extension> theme = MakeThemeExtension();
 
-  // Now check a different kind of extension.
-  scoped_refptr<extensions::Extension> extension = MakeExtension(false);
-  EXPECT_FALSE(supervised_user_service->UserMayLoad(extension.get(), &error_1));
-  EXPECT_FALSE(error_1.empty());
+    base::string16 error_1;
+    EXPECT_TRUE(supervised_user_service->UserMayLoad(theme.get(), &error_1));
+    EXPECT_TRUE(error_1.empty());
 
-  base::string16 error_2;
-  EXPECT_FALSE(supervised_user_service->UserMayModifySettings(extension.get(),
-                                                              &error_2));
-  EXPECT_FALSE(error_2.empty());
+    base::string16 error_2;
+    EXPECT_FALSE(
+        supervised_user_service->MustRemainInstalled(theme.get(), &error_2));
+    EXPECT_TRUE(error_2.empty());
+  }
 
-  // Check that an extension that was installed by the custodian may be loaded.
-  base::string16 error_3;
-  scoped_refptr<extensions::Extension> extension_2 = MakeExtension(true);
-  EXPECT_TRUE(supervised_user_service->UserMayLoad(extension_2.get(),
-                                                   &error_3));
-  EXPECT_TRUE(error_3.empty());
+  // Now check a different kind of extension; the supervised user should not be
+  // able to load it.
+  {
+    scoped_refptr<extensions::Extension> extension = MakeExtension(false);
 
-  // The supervised user should still not be able to uninstall or disable the
-  // extension.
-  base::string16 error_4;
-  EXPECT_FALSE(supervised_user_service->UserMayModifySettings(extension_2.get(),
-                                                              &error_4));
-  EXPECT_FALSE(error_4.empty());
+    base::string16 error;
+    EXPECT_FALSE(supervised_user_service->UserMayLoad(extension.get(), &error));
+    EXPECT_FALSE(error.empty());
+  }
+
+  {
+    // Check that a custodian-installed extension may be loaded, but not
+    // uninstalled.
+    scoped_refptr<extensions::Extension> extension = MakeExtension(true);
+
+    base::string16 error_1;
+    EXPECT_TRUE(
+        supervised_user_service->UserMayLoad(extension.get(), &error_1));
+    EXPECT_TRUE(error_1.empty());
+
+    base::string16 error_2;
+    EXPECT_TRUE(
+        supervised_user_service->MustRemainInstalled(extension.get(),
+                                                     &error_2));
+    EXPECT_FALSE(error_2.empty());
+  }
 
 #ifndef NDEBUG
   EXPECT_FALSE(supervised_user_service->GetDebugPolicyProviderName().empty());
 #endif
 }
 
 TEST_F(SupervisedUserServiceExtensionTest, NoContentPacks) {
   SupervisedUserService* supervised_user_service =
       SupervisedUserServiceFactory::GetForProfile(profile_.get());
   SupervisedUserURLFilter* url_filter =
@@ skipping 86 matching lines @@
   ASSERT_EQ(1u, site_list_observer_.sites().size());
   EXPECT_EQ(base::ASCIIToUTF16("Moose"), site_list_observer_.sites()[0].name);
 
   url_filter_observer_.Wait();
   EXPECT_EQ(SupervisedUserURLFilter::WARN,
             url_filter->GetFilteringBehaviorForURL(example_url));
   EXPECT_EQ(SupervisedUserURLFilter::ALLOW,
             url_filter->GetFilteringBehaviorForURL(moose_url));
 }
 #endif  // defined(ENABLE_EXTENSIONS)