Mark supervised profiles as such immediately when they're created.

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/strings/utf_string_conversions.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_service_unittest.h"
 #include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/managed_mode/custodian_profile_downloader_service.h"
 #include "chrome/browser/managed_mode/custodian_profile_downloader_service_factory.h"
 #include "chrome/browser/managed_mode/managed_user_service.h"
 #include "chrome/browser/managed_mode/managed_user_service_factory.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_builder.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_profile.h"
-#include "content/public/test/test_browser_thread.h"
+#include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_utils.h"
 #include "extensions/common/manifest_constants.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::MessageLoopRunner;
 
 namespace {
 
 void OnProfileDownloadedFail(const string16& full_name) {
   ASSERT_TRUE(false) << "Profile download should not have succeeded.";
@@ skipping 25 matching lines @@
   void Reset() {
     message_loop_runner_ = new MessageLoopRunner;
   }
 
   ManagedModeURLFilter* url_filter_;
   scoped_refptr<MessageLoopRunner> message_loop_runner_;
 };
 
 class ManagedUserServiceTest : public ::testing::Test {
  public:
-  ManagedUserServiceTest() : ui_thread_(content::BrowserThread::UI,
-                                        &message_loop_) {
+  ManagedUserServiceTest() {
     managed_user_service_ = ManagedUserServiceFactory::GetForProfile(&profile_);
   }
 
   virtual ~ManagedUserServiceTest() {}
 
  protected:
-  base::MessageLoop message_loop_;
-  content::TestBrowserThread ui_thread_;
+  content::TestBrowserThreadBundle thread_bundle_;
   TestingProfile profile_;
   ManagedUserService* managed_user_service_;
 };
 
 }  // 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");
@@ skipping 56 matching lines @@
   CustodianProfileDownloaderService* downloader_service =
       CustodianProfileDownloaderServiceFactory::GetForProfile(
           &profile_);
 
   // Emulate being logged in, then start to download a profile so a
   // ProfileDownloader gets created.
   profile_.GetPrefs()->SetString(prefs::kGoogleServicesUsername, "Logged In");
   downloader_service->DownloadProfile(base::Bind(&OnProfileDownloadedFail));
 }
 
-class ManagedUserServiceExtensionTest : public ExtensionServiceTestBase {
+class ManagedUserServiceExtensionTestBase : public ExtensionServiceTestBase {
  public:
-  ManagedUserServiceExtensionTest() {}
-  virtual ~ManagedUserServiceExtensionTest() {}
+  explicit ManagedUserServiceExtensionTestBase(bool is_managed)
+      : is_managed_(is_managed) {}
+  virtual ~ManagedUserServiceExtensionTestBase() {}
 
   virtual void SetUp() OVERRIDE {
     ExtensionServiceTestBase::SetUp();
-    InitializeEmptyExtensionService();
-  }
-
-  virtual void TearDown() OVERRIDE {
-    ExtensionServiceTestBase::TearDown();
+    ExtensionServiceTestBase::ExtensionServiceInitParams params =
+        CreateDefaultInitParams();
+    params.profile_is_managed = is_managed_;
+    InitializeExtensionService(params);
+    ManagedUserServiceFactory::GetForProfile(profile_.get())->Init();
   }
 
  protected:
   ScopedVector<ManagedModeSiteList> GetActiveSiteLists(
       ManagedUserService* managed_user_service) {
     return managed_user_service->GetActiveSiteLists();
   }
 
   scoped_refptr<extensions::Extension> MakeThemeExtension() {
     scoped_ptr<DictionaryValue> source(new DictionaryValue());
     source->SetString(extensions::manifest_keys::kName, "Theme");
     source->Set(extensions::manifest_keys::kTheme, new 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_ptr<DictionaryValue> manifest = extensions::DictionaryBuilder()
       .Set(extensions::manifest_keys::kName, "Extension")
       .Set(extensions::manifest_keys::kVersion, "1.0")
       .Build();
     extensions::ExtensionBuilder builder;
     scoped_refptr<extensions::Extension> extension =
         builder.SetManifest(manifest.Pass()).Build();
     return extension;
   }
+
+  bool is_managed_;
 };
 
-TEST_F(ManagedUserServiceExtensionTest,
-       ExtensionManagementPolicyProviderUnmanaged) {
+class ManagedUserServiceExtensionTestUnmanaged
+    : public ManagedUserServiceExtensionTestBase {
+ public:
+  ManagedUserServiceExtensionTestUnmanaged()
+      : ManagedUserServiceExtensionTestBase(false) {}
+};
+
+class ManagedUserServiceExtensionTest
+    : public ManagedUserServiceExtensionTestBase {
+ public:
+  ManagedUserServiceExtensionTest()
+      : ManagedUserServiceExtensionTestBase(true) {}
+};
+
+TEST_F(ManagedUserServiceExtensionTestUnmanaged,
+       ExtensionManagementPolicyProvider) {
   ManagedUserService* managed_user_service =
       ManagedUserServiceFactory::GetForProfile(profile_.get());
   EXPECT_FALSE(profile_->IsManaged());
 
   scoped_refptr<extensions::Extension> extension = MakeExtension();
   string16 error_1;
   EXPECT_TRUE(managed_user_service->UserMayLoad(extension.get(), &error_1));
   EXPECT_EQ(string16(), error_1);
 
   string16 error_2;
   EXPECT_TRUE(
       managed_user_service->UserMayModifySettings(extension.get(), &error_2));
   EXPECT_EQ(string16(), error_2);
 }
 
-TEST_F(ManagedUserServiceExtensionTest,
-       ExtensionManagementPolicyProviderManaged) {
+TEST_F(ManagedUserServiceExtensionTest, ExtensionManagementPolicyProvider) {
   ManagedUserService* managed_user_service =
       ManagedUserServiceFactory::GetForProfile(profile_.get());
-  managed_user_service->InitForTesting();
   ManagedModeURLFilterObserver observer(
       managed_user_service->GetURLFilterForUIThread());
-  EXPECT_TRUE(profile_->IsManaged());
+  ASSERT_TRUE(profile_->IsManaged());
   // 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();
   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));
   EXPECT_TRUE(error_1.empty());
 
   // Now check a different kind of extension.
   scoped_refptr<extensions::Extension> extension = MakeExtension();
   EXPECT_FALSE(managed_user_service->UserMayLoad(extension.get(), &error_1));
   EXPECT_FALSE(error_1.empty());
 
   string16 error_2;
   EXPECT_FALSE(
       managed_user_service->UserMayModifySettings(extension.get(), &error_2));
   EXPECT_FALSE(error_2.empty());
 
 #ifndef NDEBUG
   EXPECT_FALSE(managed_user_service->GetDebugPolicyProviderName().empty());
 #endif
 }
 
-
 TEST_F(ManagedUserServiceExtensionTest, NoContentPacks) {
   ManagedUserService* managed_user_service =
       ManagedUserServiceFactory::GetForProfile(profile_.get());
-  managed_user_service->Init();
   ManagedModeURLFilter* url_filter =
       managed_user_service->GetURLFilterForUIThread();
 
   GURL url("http://youtube.com");
   ScopedVector<ManagedModeSiteList> site_lists =
       GetActiveSiteLists(managed_user_service);
   ASSERT_EQ(0u, site_lists.size());
   EXPECT_EQ(ManagedModeURLFilter::ALLOW,
             url_filter->GetFilteringBehaviorForURL(url));
 }
 
 TEST_F(ManagedUserServiceExtensionTest, InstallContentPacks) {
   ManagedUserService* managed_user_service =
       ManagedUserServiceFactory::GetForProfile(profile_.get());
-  managed_user_service->InitForTesting();
   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));
 
@@ skipping 83 matching lines @@
   sites.clear();
   site_lists[0]->GetSites(&sites);
   ASSERT_EQ(1u, sites.size());
   EXPECT_EQ(ASCIIToUTF16("Moose"), sites[0].name);
 
   EXPECT_EQ(ManagedModeURLFilter::WARN,
             url_filter->GetFilteringBehaviorForURL(example_url));
   EXPECT_EQ(ManagedModeURLFilter::ALLOW,
             url_filter->GetFilteringBehaviorForURL(moose_url));
 }