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

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 "chrome/browser/extensions/extension_service_unittest.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 431 matching lines @@
   int expected_creation_flags_;
   scoped_ptr<extensions::ExternalProviderImpl> provider_;
   scoped_ptr<DictionaryValue> prefs_;
   scoped_ptr<TestingProfile> profile_;
 
   DISALLOW_COPY_AND_ASSIGN(MockProviderVisitor);
 };
 
 ExtensionServiceTestBase::ExtensionServiceInitParams::
 ExtensionServiceInitParams()
- : autoupdate_enabled(false), is_first_run(true) {
+    : autoupdate_enabled(false), is_first_run(true), profile_is_managed(false) {
 }
 
 // Our message loop may be used in tests which require it to be an IO loop.
 ExtensionServiceTestBase::ExtensionServiceTestBase()
     : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
       service_(NULL),
       management_policy_(NULL),
       expected_extensions_count_(0) {
   base::FilePath test_data_dir;
   if (!PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir)) {
@@ skipping 17 matching lines @@
   if (!params.pref_file.empty()) {
     builder.WithUserFilePrefs(params.pref_file,
                               base::MessageLoopProxy::current().get());
     scoped_refptr<user_prefs::PrefRegistrySyncable> registry(
         new user_prefs::PrefRegistrySyncable);
     scoped_ptr<PrefServiceSyncable> prefs(
         builder.CreateSyncable(registry.get()));
     chrome::RegisterUserProfilePrefs(registry.get());
     profile_builder.SetPrefService(prefs.Pass());
   }
+
+  if (params.profile_is_managed)
+    profile_builder.SetManagedUserId("asdf");
+
   profile_builder.SetPath(params.profile_path);
   profile_ = profile_builder.Build();
 
   TestExtensionSystem* system = static_cast<TestExtensionSystem*>(
       ExtensionSystem::Get(profile_.get()));
   if (!params.is_first_run) {
     ExtensionPrefs* prefs = system->CreateExtensionPrefs(
         CommandLine::ForCurrentProcess(),
         params.extensions_install_dir);
     prefs->SetAlertSystemFirstRun();
   }
 
   service_ = system->CreateExtensionService(
       CommandLine::ForCurrentProcess(),
       params.extensions_install_dir,
       params.autoupdate_enabled);
   service_->SetFileTaskRunnerForTesting(
       base::MessageLoopProxy::current().get());
   service_->set_extensions_enabled(true);
   service_->set_show_extensions_prompts(false);
   service_->set_install_updates_when_idle_for_test(false);
 
   management_policy_ =
       ExtensionSystem::Get(profile_.get())->management_policy();
 
+  extensions_install_dir_ = params.extensions_install_dir;
+
   // When we start up, we want to make sure there is no external provider,
   // since the ExtensionService on Windows will use the Registry as a default
   // provider and if there is something already registered there then it will
   // interfere with the tests. Those tests that need an external provider
   // will register one specifically.
   service_->ClearProvidersForTesting();
 
 #if defined(OS_CHROMEOS)
   extensions::InstallLimiter::Get(profile_.get())->DisableForTest();
 #endif
 
   expected_extensions_count_ = 0;
 }
 
 void ExtensionServiceTestBase::InitializeInstalledExtensionService(
     const base::FilePath& prefs_file,
     const base::FilePath& source_install_dir) {
-  ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
+  EXPECT_TRUE(temp_dir_.CreateUniqueTempDir());
   base::FilePath path = temp_dir_.path();
   path = path.Append(FILE_PATH_LITERAL("TestingExtensionsPath"));
-  base::DeleteFile(path, true);
-  file_util::CreateDirectory(path);
+  EXPECT_TRUE(base::DeleteFile(path, true));
+  base::PlatformFileError error = base::PLATFORM_FILE_OK;
+  EXPECT_TRUE(file_util::CreateDirectoryAndGetError(path, &error)) << error;
   base::FilePath temp_prefs = path.Append(FILE_PATH_LITERAL("Preferences"));
-  base::CopyFile(prefs_file, temp_prefs);
+  EXPECT_TRUE(base::CopyFile(prefs_file, temp_prefs));
 
-  extensions_install_dir_ = path.Append(FILE_PATH_LITERAL("Extensions"));
-  base::DeleteFile(extensions_install_dir_, true);
-  base::CopyDirectory(source_install_dir, extensions_install_dir_, true);
+  base::FilePath extensions_install_dir =
+      path.Append(FILE_PATH_LITERAL("Extensions"));
+  EXPECT_TRUE(base::DeleteFile(extensions_install_dir, true));
+  EXPECT_TRUE(
+      base::CopyDirectory(source_install_dir, extensions_install_dir, true));
 
   ExtensionServiceInitParams params;
   params.profile_path = path;
   params.pref_file = temp_prefs;
-  params.extensions_install_dir = extensions_install_dir_;
+  params.extensions_install_dir = extensions_install_dir;
   InitializeExtensionService(params);
 }
 
 void ExtensionServiceTestBase::InitializeGoodInstalledExtensionService() {
   base::FilePath source_install_dir = data_dir_
       .AppendASCII("good")
       .AppendASCII("Extensions");
   base::FilePath pref_path = source_install_dir
       .DirName()
       .AppendASCII("Preferences");
   InitializeInstalledExtensionService(pref_path, source_install_dir);
 }
 
 void ExtensionServiceTestBase::InitializeEmptyExtensionService() {
-  InitializeExtensionServiceHelper(false, true);
+  InitializeExtensionService(CreateDefaultInitParams());
 }
 
 void ExtensionServiceTestBase::InitializeExtensionProcessManager() {
   static_cast<extensions::TestExtensionSystem*>(
       ExtensionSystem::Get(profile_.get()))->
       CreateExtensionProcessManager();
 }
 
 void ExtensionServiceTestBase::InitializeExtensionServiceWithUpdater() {
-  InitializeExtensionServiceHelper(true, true);
+  ExtensionServiceInitParams params = CreateDefaultInitParams();
+  params.autoupdate_enabled = true;
+  InitializeExtensionService(params);
   service_->updater()->Start();
 }
 
-void ExtensionServiceTestBase::InitializeExtensionServiceHelper(
-    bool autoupdate_enabled, bool is_first_run) {
-  ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
+ExtensionServiceTestBase::ExtensionServiceInitParams
+ExtensionServiceTestBase::CreateDefaultInitParams() {
+  ExtensionServiceInitParams params;
+  EXPECT_TRUE(temp_dir_.CreateUniqueTempDir());
   base::FilePath path = temp_dir_.path();
   path = path.Append(FILE_PATH_LITERAL("TestingExtensionsPath"));
-  base::DeleteFile(path, true);
-  file_util::CreateDirectory(path);
+  EXPECT_TRUE(base::DeleteFile(path, true));
+  base::PlatformFileError error = base::PLATFORM_FILE_OK;
+  EXPECT_TRUE(file_util::CreateDirectoryAndGetError(path, &error)) << error;
   base::FilePath prefs_filename =
       path.Append(FILE_PATH_LITERAL("TestPreferences"));
-  extensions_install_dir_ = path.Append(FILE_PATH_LITERAL("Extensions"));
-  base::DeleteFile(extensions_install_dir_, true);
-  file_util::CreateDirectory(extensions_install_dir_);
+  base::FilePath extensions_install_dir =
+      path.Append(FILE_PATH_LITERAL("Extensions"));
+  EXPECT_TRUE(base::DeleteFile(extensions_install_dir, true));
+  EXPECT_TRUE(file_util::CreateDirectoryAndGetError(extensions_install_dir,
+                                                    &error)) << error;
 
-  ExtensionServiceInitParams params;
   params.profile_path = path;
   params.pref_file = prefs_filename;
-  params.extensions_install_dir = extensions_install_dir_;
-  params.autoupdate_enabled = autoupdate_enabled;
-  params.is_first_run = is_first_run;
-  InitializeExtensionService(params);
+  params.extensions_install_dir = extensions_install_dir;
+  return params;
 }
 
 // static
 void ExtensionServiceTestBase::SetUpTestCase() {
   ExtensionErrorReporter::Init(false);  // no noisy errors
 }
 
 void ExtensionServiceTestBase::SetUp() {
   ExtensionErrorReporter::GetInstance()->ClearErrors();
   content::RenderProcessHost::SetRunRendererInProcess(true);
@@ skipping 5862 matching lines @@
 }
 
 // Test that there is a bubble for external extensions that update
 // from the webstore if the profile is not new.
 TEST_F(ExtensionServiceTest, ExternalInstallUpdatesFromWebstoreOldProfile) {
   FeatureSwitch::ScopedOverride prompt(
       FeatureSwitch::prompt_for_external_extensions(), true);
 
   // This sets up the ExtensionPrefs used by our ExtensionService to be
   // post-first run.
-  InitializeExtensionServiceHelper(false, false);
+  ExtensionServiceInitParams params = CreateDefaultInitParams();
+  params.is_first_run = false;
+  InitializeExtensionService(params);
 
   base::FilePath crx_path = temp_dir_.path().AppendASCII("webstore.crx");
   PackCRX(data_dir_.AppendASCII("update_from_webstore"),
           data_dir_.AppendASCII("update_from_webstore.pem"),
           crx_path);
 
   MockExtensionProvider* provider =
       new MockExtensionProvider(service_, Manifest::EXTERNAL_PREF);
   AddMockExternalProvider(provider);
   provider->UpdateOrAddExtension(updates_from_webstore, "1", crx_path);
@@ skipping 127 matching lines @@
   // ReconcileKnownDisabled().
   service_->EnableExtension(good2);
   service_->ReconcileKnownDisabled();
   expected_extensions.insert(good2);
   expected_disabled_extensions.erase(good2);
 
   EXPECT_EQ(expected_extensions, service_->extensions()->GetIDs());
   EXPECT_EQ(expected_disabled_extensions,
             service_->disabled_extensions()->GetIDs());
 }