Improve settings override bubble to indicate policy installed extensions

chrome/browser/extensions/extension_service_test_with_install.cc

 // Copyright 2015 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_test_with_install.h"
 
 #include "base/files/file_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_creator.h"
@@ skipping 83 matching lines @@
                            pem_output_path,
                            ExtensionCreator::kOverwriteCRX));
 
   ASSERT_TRUE(base::PathExists(crx_path));
 }
 
 const Extension* ExtensionServiceTestWithInstall::PackAndInstallCRX(
     const base::FilePath& dir_path,
     const base::FilePath& pem_path,
     InstallState install_state,
-    int creation_flags) {
+    int creation_flags,
+    Manifest::Location install_location) {
   base::FilePath crx_path;
   base::ScopedTempDir temp_dir;
   EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
   crx_path = temp_dir.GetPath().AppendASCII("temp.crx");
+  PackCRX(dir_path, pem_path, crx_path);
 
-  PackCRX(dir_path, pem_path, crx_path);
-  return InstallCRX(crx_path, install_state, creation_flags);
+  return InstallCRX(crx_path, install_location, install_state, creation_flags);
 }
 
 const Extension* ExtensionServiceTestWithInstall::PackAndInstallCRX(
     const base::FilePath& dir_path,
     const base::FilePath& pem_path,
     InstallState install_state) {
   return PackAndInstallCRX(dir_path, pem_path, install_state,
-                           Extension::NO_FLAGS);
+                           Extension::NO_FLAGS, Manifest::Location::INTERNAL);
 }
 
 const Extension* ExtensionServiceTestWithInstall::PackAndInstallCRX(
     const base::FilePath& dir_path,
     InstallState install_state) {
   return PackAndInstallCRX(dir_path, base::FilePath(), install_state,
-                           Extension::NO_FLAGS);
+                           Extension::NO_FLAGS, Manifest::Location::INTERNAL);
+}
+
+const Extension* ExtensionServiceTestWithInstall::PackAndInstallCRX(
+    const base::FilePath& dir_path,
+    Manifest::Location install_location,
+    InstallState install_state) {
+  return PackAndInstallCRX(dir_path, base::FilePath(), install_state,
+                           Extension::NO_FLAGS, install_location);
 }
 
 // Attempts to install an extension. Use INSTALL_FAILED if the installation
 // is expected to fail.
 // If |install_state| is INSTALL_UPDATED, and |expected_old_name| is
 // non-empty, expects that the existing extension's title was
 // |expected_old_name|.
 const Extension* ExtensionServiceTestWithInstall::InstallCRX(
     const base::FilePath& path,
     InstallState install_state,
     int creation_flags,
     const std::string& expected_old_name) {
-  InstallCRXInternal(path, creation_flags);
-  return VerifyCrxInstall(path, install_state, expected_old_name);
+  InstallCRXInternal(path, Manifest::Location::INTERNAL, install_state,
+                     creation_flags);
+  return VerifyCrxInstall(path, install_state);
+}
+
+const Extension* ExtensionServiceTestWithInstall::InstallCRX(
+    const base::FilePath& path,
+    Manifest::Location install_location,
+    InstallState install_state,
+    int creation_flags) {
+  InstallCRXInternal(path, install_location, install_state, creation_flags);
+  return VerifyCrxInstall(path, install_state);
 }
 
 // Attempts to install an extension. Use INSTALL_FAILED if the installation
 // is expected to fail.
 const Extension* ExtensionServiceTestWithInstall::InstallCRX(
     const base::FilePath& path,
     InstallState install_state,
     int creation_flags) {
   return InstallCRX(path, install_state, creation_flags, std::string());
 }
 
 // Attempts to install an extension. Use INSTALL_FAILED if the installation
 // is expected to fail.
 const Extension* ExtensionServiceTestWithInstall::InstallCRX(
     const base::FilePath& path,
     InstallState install_state) {
   return InstallCRX(path, install_state, Extension::NO_FLAGS);
 }
 
 const Extension* ExtensionServiceTestWithInstall::InstallCRXFromWebStore(
     const base::FilePath& path,
     InstallState install_state) {
-  InstallCRXInternal(path, Extension::FROM_WEBSTORE);
+  InstallCRXInternal(path, Manifest::Location::INTERNAL, install_state,
+                     Extension::FROM_WEBSTORE);
   return VerifyCrxInstall(path, install_state);
 }
 
-const Extension* ExtensionServiceTestWithInstall::InstallCRXWithLocation(
-    const base::FilePath& crx_path,
-    Manifest::Location install_location,
-    InstallState install_state) {
-  EXPECT_TRUE(base::PathExists(crx_path))
-      << "Path does not exist: "<< crx_path.value().c_str();
-  // no client (silent install)
-  scoped_refptr<CrxInstaller> installer(
-      CrxInstaller::CreateSilent(service()));
-  installer->set_install_source(install_location);
-
-  content::WindowedNotificationObserver observer(
-      extensions::NOTIFICATION_CRX_INSTALLER_DONE,
-      content::NotificationService::AllSources());
-  installer->InstallCrx(crx_path);
-  observer.Wait();
-
-  return VerifyCrxInstall(crx_path, install_state);
-}
-
 const Extension* ExtensionServiceTestWithInstall::VerifyCrxInstall(
     const base::FilePath& path,
     InstallState install_state) {
   return VerifyCrxInstall(path, install_state, std::string());
 }
 
 const Extension* ExtensionServiceTestWithInstall::VerifyCrxInstall(
     const base::FilePath& path,
     InstallState install_state,
     const std::string& expected_old_name) {
@@ skipping 126 matching lines @@
     const std::string& id,
     bool use_helper,
     Extension::State expected_state) {
   // Verify that the extension is installed.
   base::FilePath extension_path = extensions_install_dir().AppendASCII(id);
   EXPECT_TRUE(base::PathExists(extension_path));
   size_t pref_key_count = GetPrefKeyCount();
   EXPECT_GT(pref_key_count, 0u);
   ValidateIntegerPref(id, "state", expected_state);
 
+  // We make a copy of the extension's id since the extension can be deleted
+  // once it's uninstalled.
+  std::string extension_id = id;
   // Uninstall it.
   if (use_helper) {
     EXPECT_TRUE(ExtensionService::UninstallExtensionHelper(
         service(), id, extensions::UNINSTALL_REASON_FOR_TESTING));
   } else {
     EXPECT_TRUE(service()->UninstallExtension(
         id, extensions::UNINSTALL_REASON_FOR_TESTING,
         base::Bind(&base::DoNothing), nullptr));
   }
   --expected_extensions_count_;
 
   // We should get an unload notification.
   EXPECT_FALSE(unloaded_id_.empty());
-  EXPECT_EQ(id, unloaded_id_);
+  EXPECT_EQ(extension_id, unloaded_id_);
 
   // Verify uninstalled state.
   size_t new_pref_key_count = GetPrefKeyCount();
   if (new_pref_key_count == pref_key_count) {
     ValidateIntegerPref(id, "state",
                         Extension::EXTERNAL_EXTENSION_UNINSTALLED);
   } else {
     EXPECT_EQ(new_pref_key_count, pref_key_count - 1);
   }
 
   // The extension should not be in the service anymore.
-  EXPECT_FALSE(service()->GetInstalledExtension(id));
+  EXPECT_FALSE(service()->GetInstalledExtension(extension_id));
   base::RunLoop().RunUntilIdle();
 
   // The directory should be gone.
   EXPECT_FALSE(base::PathExists(extension_path));
 }
 
 void ExtensionServiceTestWithInstall::TerminateExtension(
     const std::string& id) {
   const Extension* extension = service()->GetInstalledExtension(id);
   if (!extension) {
@@ skipping 35 matching lines @@
   installed_ = extension;
   was_update_ = is_update;
   old_name_ = old_name;
 }
 
 // Create a CrxInstaller and install the CRX file.
 // Instead of calling this method yourself, use InstallCRX(), which does extra
 // error checking.
 void ExtensionServiceTestWithInstall::InstallCRXInternal(
     const base::FilePath& crx_path,
+    Manifest::Location install_location,
+    InstallState install_state,
     int creation_flags) {
-  ASSERT_TRUE(base::PathExists(crx_path))
-      << "Path does not exist: "<< crx_path.value().c_str();
+  EXPECT_TRUE(base::PathExists(crx_path)) << "Path does not exist: "
+                                          << crx_path.value().c_str();
+  // no client (silent install)
   scoped_refptr<CrxInstaller> installer(
       CrxInstaller::CreateSilent(service()));
+  installer->set_install_source(install_location);
   installer->set_creation_flags(creation_flags);
   if (!(creation_flags & Extension::WAS_INSTALLED_BY_DEFAULT))
     installer->set_allow_silent_install(true);
 
   content::WindowedNotificationObserver observer(
       extensions::NOTIFICATION_CRX_INSTALLER_DONE,
       content::Source<extensions::CrxInstaller>(installer.get()));
 
   installer->InstallCrx(crx_path);
-
   observer.Wait();
 }
 
 }  // namespace extensions