Rename "managed (mode|user)" to "supervised user" (part 1)

chrome/browser/managed_mode/managed_user_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 "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_test_base.h"
@@ skipping 85 matching lines @@
 }  // namespace
 
 TEST_F(ManagedUserServiceTest, GetManualExceptionsForHost) {
   GURL kExampleFooURL("http://www.example.com/foo");
   GURL kExampleBarURL("http://www.example.com/bar");
   GURL kExampleFooNoWWWURL("http://example.com/foo");
   GURL kBlurpURL("http://blurp.net/bla");
   GURL kMooseURL("http://moose.org/baz");
   {
     DictionaryPrefUpdate update(profile_->GetPrefs(),
-                                prefs::kManagedModeManualURLs);
+                                prefs::kSupervisedUserManualURLs);
     base::DictionaryValue* dict = update.Get();
     dict->SetBooleanWithoutPathExpansion(kExampleFooURL.spec(), true);
     dict->SetBooleanWithoutPathExpansion(kExampleBarURL.spec(), false);
     dict->SetBooleanWithoutPathExpansion(kExampleFooNoWWWURL.spec(), true);
     dict->SetBooleanWithoutPathExpansion(kBlurpURL.spec(), true);
   }
 
   EXPECT_EQ(ManagedUserService::MANUAL_ALLOW,
             managed_user_service_->GetManualBehaviorForURL(kExampleFooURL));
   EXPECT_EQ(ManagedUserService::MANUAL_BLOCK,
             managed_user_service_->GetManualBehaviorForURL(kExampleBarURL));
   EXPECT_EQ(ManagedUserService::MANUAL_ALLOW,
             managed_user_service_->GetManualBehaviorForURL(
                 kExampleFooNoWWWURL));
   EXPECT_EQ(ManagedUserService::MANUAL_ALLOW,
             managed_user_service_->GetManualBehaviorForURL(kBlurpURL));
   EXPECT_EQ(ManagedUserService::MANUAL_NONE,
             managed_user_service_->GetManualBehaviorForURL(kMooseURL));
   std::vector<GURL> exceptions;
   managed_user_service_->GetManualExceptionsForHost("www.example.com",
                                                     &exceptions);
   ASSERT_EQ(2u, exceptions.size());
   EXPECT_EQ(kExampleBarURL, exceptions[0]);
   EXPECT_EQ(kExampleFooURL, exceptions[1]);
 
   {
     DictionaryPrefUpdate update(profile_->GetPrefs(),
-                                prefs::kManagedModeManualURLs);
+                                prefs::kSupervisedUserManualURLs);
     base::DictionaryValue* dict = update.Get();
     for (std::vector<GURL>::iterator it = exceptions.begin();
          it != exceptions.end(); ++it) {
       dict->RemoveWithoutPathExpansion(it->spec(), NULL);
     }
   }
 
   EXPECT_EQ(ManagedUserService::MANUAL_NONE,
             managed_user_service_->GetManualBehaviorForURL(kExampleFooURL));
   EXPECT_EQ(ManagedUserService::MANUAL_NONE,
@@ skipping 25 matching lines @@
  public:
   explicit ManagedUserServiceExtensionTestBase(bool is_managed)
       : is_managed_(is_managed),
         channel_(chrome::VersionInfo::CHANNEL_DEV) {}
   virtual ~ManagedUserServiceExtensionTestBase() {}
 
   virtual void SetUp() OVERRIDE {
     ExtensionServiceTestBase::SetUp();
     ExtensionServiceTestBase::ExtensionServiceInitParams params =
         CreateDefaultInitParams();
-    params.profile_is_managed = is_managed_;
+    params.profile_is_supervised = is_managed_;
     InitializeExtensionService(params);
     ManagedUserServiceFactory::GetForProfile(profile_.get())->Init();
   }
 
  protected:
   ScopedVector<ManagedModeSiteList> GetActiveSiteLists(
       ManagedUserService* managed_user_service) {
     return managed_user_service->GetActiveSiteLists();
   }
 
@@ skipping 34 matching lines @@
     : public ManagedUserServiceExtensionTestBase {
  public:
   ManagedUserServiceExtensionTest()
       : ManagedUserServiceExtensionTestBase(true) {}
 };
 
 TEST_F(ManagedUserServiceExtensionTestUnmanaged,
        ExtensionManagementPolicyProvider) {
   ManagedUserService* managed_user_service =
       ManagedUserServiceFactory::GetForProfile(profile_.get());
-  EXPECT_FALSE(profile_->IsManaged());
+  EXPECT_FALSE(profile_->IsSupervised());
 
   scoped_refptr<extensions::Extension> extension = MakeExtension();
   base::string16 error_1;
   EXPECT_TRUE(managed_user_service->UserMayLoad(extension.get(), &error_1));
   EXPECT_EQ(base::string16(), error_1);
 
   base::string16 error_2;
   EXPECT_TRUE(
       managed_user_service->UserMayModifySettings(extension.get(), &error_2));
   EXPECT_EQ(base::string16(), error_2);
 }
 
 TEST_F(ManagedUserServiceExtensionTest, ExtensionManagementPolicyProvider) {
   ManagedUserService* managed_user_service =
       ManagedUserServiceFactory::GetForProfile(profile_.get());
   ManagedModeURLFilterObserver observer(
       managed_user_service->GetURLFilterForUIThread());
-  ASSERT_TRUE(profile_->IsManaged());
+  ASSERT_TRUE(profile_->IsSupervised());
   // Wait for the initial update to finish (otherwise we'll get leaks).
   observer.Wait();
 
   // Check that a supervised user can install a theme.
   scoped_refptr<extensions::Extension> theme = MakeThemeExtension();
   base::string16 error_1;
   EXPECT_TRUE(managed_user_service->UserMayLoad(theme.get(), &error_1));
   EXPECT_TRUE(error_1.empty());
   EXPECT_TRUE(
       managed_user_service->UserMayModifySettings(theme.get(), &error_1));
@@ skipping 34 matching lines @@
   ManagedModeURLFilter* url_filter =
       managed_user_service->GetURLFilterForUIThread();
   ManagedModeURLFilterObserver observer(url_filter);
   observer.Wait();
 
   GURL example_url("http://example.com");
   GURL moose_url("http://moose.org");
   EXPECT_EQ(ManagedModeURLFilter::ALLOW,
             url_filter->GetFilteringBehaviorForURL(example_url));
 
-  profile_->GetPrefs()->SetInteger(prefs::kDefaultManagedModeFilteringBehavior,
-                                   ManagedModeURLFilter::BLOCK);
+  profile_->GetPrefs()->SetInteger(
+      prefs::kDefaultSupervisedUserFilteringBehavior,
+      ManagedModeURLFilter::BLOCK);
   EXPECT_EQ(ManagedModeURLFilter::BLOCK,
             url_filter->GetFilteringBehaviorForURL(example_url));
 
-  profile_->GetPrefs()->SetInteger(prefs::kDefaultManagedModeFilteringBehavior,
-                                   ManagedModeURLFilter::WARN);
+  profile_->GetPrefs()->SetInteger(
+      prefs::kDefaultSupervisedUserFilteringBehavior,
+      ManagedModeURLFilter::WARN);
   EXPECT_EQ(ManagedModeURLFilter::WARN,
             url_filter->GetFilteringBehaviorForURL(example_url));
 
   managed_user_service->set_elevated_for_testing(true);
 
   // Load a content pack.
   scoped_refptr<extensions::UnpackedInstaller> installer(
       extensions::UnpackedInstaller::Create(service_));
   installer->set_prompt_for_plugins(false);
   base::FilePath test_data_dir;
@@ skipping 67 matching lines @@
   site_lists[0]->GetSites(&sites);
   ASSERT_EQ(1u, sites.size());
   EXPECT_EQ(base::ASCIIToUTF16("Moose"), sites[0].name);
 
   EXPECT_EQ(ManagedModeURLFilter::WARN,
             url_filter->GetFilteringBehaviorForURL(example_url));
   EXPECT_EQ(ManagedModeURLFilter::ALLOW,
             url_filter->GetFilteringBehaviorForURL(moose_url));
 }
 #endif  // !defined(OS_ANDROID)