Apps&Extensions for supervised users: Add test for WAS_INSTALLED_BY_CUSTODIAN flag.

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/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"
 #include "chrome/browser/extensions/extension_service.h"
@@ skipping 183 matching lines @@
     scoped_ptr<base::DictionaryValue> source(new base::DictionaryValue());
     source->SetString(extensions::manifest_keys::kName, "Theme");
     source->Set(extensions::manifest_keys::kTheme, new base::DictionaryValue());
     source->SetString(extensions::manifest_keys::kVersion, "1.0");
     extensions::ExtensionBuilder builder;
     scoped_refptr<extensions::Extension> extension =
         builder.SetManifest(source.Pass()).Build();
     return extension;
   }
 
-  scoped_refptr<extensions::Extension> MakeExtension() {
+  scoped_refptr<extensions::Extension> MakeExtension(bool by_custodian) {
     scoped_ptr<base::DictionaryValue> manifest = extensions::DictionaryBuilder()
       .Set(extensions::manifest_keys::kName, "Extension")
       .Set(extensions::manifest_keys::kVersion, "1.0")
       .Build();
+    int creation_flags = extensions::Extension::NO_FLAGS;
+    if (by_custodian)
+      creation_flags |= extensions::Extension::WAS_INSTALLED_BY_CUSTODIAN;
     extensions::ExtensionBuilder builder;
     scoped_refptr<extensions::Extension> extension =
-        builder.SetManifest(manifest.Pass()).Build();
+        builder.SetManifest(manifest.Pass()).AddFlags(creation_flags).Build();
     return extension;
   }
 
   bool is_supervised_;
   extensions::ScopedCurrentChannel channel_;
 };
 
 class SupervisedUserServiceExtensionTestUnsupervised
     : public SupervisedUserServiceExtensionTestBase {
  public:
   SupervisedUserServiceExtensionTestUnsupervised()
       : 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();
+  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);
 }
@@ skipping 10 matching lines @@
   // 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());
 
   // Now check a different kind of extension.
-  scoped_refptr<extensions::Extension> extension = MakeExtension();
+  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_2;
-  EXPECT_FALSE(
-      supervised_user_service->UserMayModifySettings(extension.get(),
-                                                     &error_2));
+  EXPECT_FALSE(supervised_user_service->UserMayModifySettings(extension.get(),
+                                                              &error_2));
   EXPECT_FALSE(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());
+
+  // 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());
+
 #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 =
       supervised_user_service->GetURLFilterForUIThread();
@@ skipping 108 matching lines @@
   site_lists[0]->GetSites(&sites);
   ASSERT_EQ(1u, sites.size());
   EXPECT_EQ(base::ASCIIToUTF16("Moose"), sites[0].name);
 
   EXPECT_EQ(SupervisedUserURLFilter::WARN,
             url_filter->GetFilteringBehaviorForURL(example_url));
   EXPECT_EQ(SupervisedUserURLFilter::ALLOW,
             url_filter->GetFilteringBehaviorForURL(moose_url));
 }
 #endif  // !defined(OS_ANDROID)