Enable WebContents elevation for managed users.

chrome/browser/managed_mode/managed_user_service.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/managed_mode/managed_user_service.h"
 
 #include "base/memory/ref_counted.h"
 #include "base/prefs/pref_service.h"
 #include "base/sequenced_task_runner.h"
 #include "chrome/browser/extensions/extension_service.h"
@@ skipping 86 matching lines @@
 void ManagedUserService::URLFilterContext::SetManualURLs(
     scoped_ptr<std::map<GURL, bool> > url_map) {
   ui_url_filter_->SetManualURLs(url_map.get());
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&ManagedModeURLFilter::SetManualURLs,
                  io_url_filter_, base::Owned(url_map.release())));
 }
 
-ManagedUserService::ManagedUserService(Profile* profile)
-    : profile_(profile),
-      is_elevated_(false) {
+ManagedUserService::ManagedUserService(Profile* profile) : profile_(profile) {
 }
 
 ManagedUserService::~ManagedUserService() {
 }
 
 bool ManagedUserService::ProfileIsManaged() const {
   return profile_->GetPrefs()->GetBoolean(prefs::kProfileIsManaged);
 }
 
-bool ManagedUserService::IsElevated() const {
-  return is_elevated_;
-}
-
 bool ManagedUserService::IsElevatedForWebContents(
     const content::WebContents* web_contents) const {
   const ManagedModeNavigationObserver* observer =
       ManagedModeNavigationObserver::FromWebContents(web_contents);
-  return observer->is_elevated();
+  return observer ? observer->is_elevated() : false;
 }
 
 bool ManagedUserService::IsPassphraseEmpty() const {
   PrefService* pref_service = profile_->GetPrefs();
   return pref_service->GetString(prefs::kManagedModeLocalPassphrase).empty();
 }
 
-bool ManagedUserService::CanSkipPassphraseDialog() {
-  // If the profile is already elevated or there is no passphrase set, no
-  // authentication is needed.
-  return IsElevated() || IsPassphraseEmpty();
-}
-
 bool ManagedUserService::CanSkipPassphraseDialog(
     const content::WebContents* web_contents) const {
-  return IsElevated() ||
-      IsElevatedForWebContents(web_contents) ||
-      IsPassphraseEmpty();
+  return IsElevatedForWebContents(web_contents) ||
+         IsPassphraseEmpty();
 }
 
 void ManagedUserService::RequestAuthorization(
     content::WebContents* web_contents,
     const PassphraseCheckedCallback& callback) {
   if (CanSkipPassphraseDialog(web_contents)) {
     callback.Run(true);
     return;
   }
 
   // Is deleted automatically when the dialog is closed.
   new ManagedUserPassphraseDialog(web_contents, callback);
 }
 
-void ManagedUserService::RequestAuthorizationUsingActiveWebContents(
-    Browser* browser,
-    const PassphraseCheckedCallback& callback) {
-  RequestAuthorization(
-      browser->tab_strip_model()->GetActiveWebContents(),
-      callback);
-}
-
 // static
 void ManagedUserService::RegisterUserPrefs(PrefRegistrySyncable* registry) {
   registry->RegisterDictionaryPref(prefs::kManagedModeManualHosts,
                                    PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterDictionaryPref(prefs::kManagedModeManualURLs,
                                    PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterIntegerPref(prefs::kDefaultManagedModeFilteringBehavior,
                                 ManagedModeURLFilter::BLOCK,
                                 PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterStringPref(prefs::kManagedModeLocalPassphrase,
@@ skipping 105 matching lines @@
     }
     case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
       const extensions::UnloadedExtensionInfo* extension_info =
           content::Details<extensions::UnloadedExtensionInfo>(details).ptr();
       if (!extensions::ManagedModeInfo::GetContentPackSiteList(
               extension_info->extension).empty()) {
         UpdateSiteLists();
       }
       break;
     }
+    case chrome::NOTIFICATION_EXTENSION_INSTALLED:
+    case chrome::NOTIFICATION_EXTENSION_UNINSTALLED: {
+      // When an extension was installed or uninstalled, remove the temporary
+      // elevation.
+      const extensions::Extension* extension =
+          content::Details<extensions::Extension>(details).ptr();
+      RemoveElevationForExtension(extension->id());
+      break;
+    }
     default:
       NOTREACHED();
   }
 }
 
 bool ManagedUserService::ExtensionManagementPolicyImpl(
     const std::string& extension_id,
     string16* error) const {
   if (!ProfileIsManaged())
     return true;
 
-  if (is_elevated_)
-    return true;
-
   if (elevated_for_extensions_.count(extension_id))
     return true;
 
   if (error)
     *error = l10n_util::GetStringUTF16(IDS_EXTENSIONS_LOCKED_MANAGED_MODE);
   return false;
 }
 
 ScopedVector<ManagedModeSiteList> ManagedUserService::GetActiveSiteLists() {
   ScopedVector<ManagedModeSiteList> site_lists;
@@ skipping 100 matching lines @@
                                                     std::vector<GURL>* urls) {
   const DictionaryValue* dict =
       profile_->GetPrefs()->GetDictionary(prefs::kManagedModeManualURLs);
   for (DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance()) {
     GURL url(it.key());
     if (url.host() == host)
       urls->push_back(url);
   }
 }
 
-// TODO(akuegel): Rename to SetElevatedForTesting when all callers are changed
-// to set elevation on the ManagedModeNavigationObserver.
-void ManagedUserService::SetElevated(bool is_elevated) {
-  is_elevated_ = is_elevated;
-}
-
 void ManagedUserService::AddElevationForExtension(
     const std::string& extension_id) {
   elevated_for_extensions_.insert(extension_id);
 }
 
 void ManagedUserService::RemoveElevationForExtension(
     const std::string& extension_id) {
   elevated_for_extensions_.erase(extension_id);
 }
 
 void ManagedUserService::Init() {
   if (!ProfileIsManaged())
     return;
 
   extensions::ExtensionSystem* extension_system =
       extensions::ExtensionSystem::Get(profile_);
   extensions::ManagementPolicy* management_policy =
       extension_system->management_policy();
   if (management_policy)
     extension_system->management_policy()->RegisterProvider(this);
 
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
                  content::Source<Profile>(profile_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
                  content::Source<Profile>(profile_));
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_INSTALLED,
+                 content::Source<Profile>(profile_));
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNINSTALLED,
+                 content::Source<Profile>(profile_));
   pref_change_registrar_.Init(profile_->GetPrefs());
   pref_change_registrar_.Add(
       prefs::kDefaultManagedModeFilteringBehavior,
       base::Bind(
           &ManagedUserService::OnDefaultFilteringBehaviorChanged,
           base::Unretained(this)));
 
   // TODO(bauerb): Setting the default value here does not currently trigger
   // the proper notification. Once that is fixed use SetDefaultPrefValue
   // instead.
@@ skipping 26 matching lines @@
       profile_->GetPrefs()->GetDictionary(prefs::kManagedModeManualURLs);
   scoped_ptr<std::map<GURL, bool> > url_map(new std::map<GURL, bool>());
   for (DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance()) {
     bool allow = false;
     bool result = it.value().GetAsBoolean(&allow);
     DCHECK(result);
     (*url_map)[GURL(it.key())] = allow;
   }
   url_filter_context_.SetManualURLs(url_map.Pass());
 }