Add managed user lock/unlock button for the extensions page.

chrome/browser/ui/webui/extensions/extension_settings_handler.cc

 // Copyright (c) 2012 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/ui/webui/extensions/extension_settings_handler.h"
 
 #include "base/auto_reset.h"
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 327 matching lines @@
   source->AddString("extensionSettingsCrashMessage",
       l10n_util::GetStringUTF16(IDS_EXTENSIONS_CRASHED_EXTENSION));
   source->AddString("extensionSettingsInDevelopment",
       l10n_util::GetStringUTF16(IDS_EXTENSIONS_IN_DEVELOPMENT));
   source->AddString("extensionSettingsWarningsTitle",
       l10n_util::GetStringUTF16(IDS_EXTENSION_WARNINGS_TITLE));
   source->AddString("extensionSettingsShowDetails",
       l10n_util::GetStringUTF16(IDS_EXTENSIONS_SHOW_DETAILS));
   source->AddString("extensionSettingsHideDetails",
       l10n_util::GetStringUTF16(IDS_EXTENSIONS_HIDE_DETAILS));
+  source->AddString("unlockButton",
+      l10n_util::GetStringUTF16(IDS_EXTENSIONS_UNLOCK_BUTTON));
+  source->AddString("lockButton",
+      l10n_util::GetStringUTF16(IDS_EXTENSIONS_LOCK_BUTTON));
 
   // TODO(estade): comb through the above strings to find ones no longer used in
   // uber extensions.
   source->AddString("extensionUninstall",
       l10n_util::GetStringUTF16(IDS_EXTENSIONS_UNINSTALL));
 }
 
 void ExtensionSettingsHandler::NavigateToPendingEntry(const GURL& url,
     content::NavigationController::ReloadType reload_type) {
   if (reload_type != content::NavigationController::NO_RELOAD)
     ReloadUnpackedExtensions();
 }
 
 void ExtensionSettingsHandler::RegisterMessages() {
   // Don't override an |extension_service_| or |management_policy_| injected
   // for testing.
   if (!extension_service_) {
     extension_service_ = Profile::FromWebUI(web_ui())->GetOriginalProfile()->
         GetExtensionService();
   }
   if (!management_policy_) {
     management_policy_ = extensions::ExtensionSystem::Get(
         extension_service_->profile())->management_policy();
   }
 
+  web_ui()->RegisterMessageCallback("setElevated",
+      base::Bind(&ExtensionSettingsHandler::ManagedUserSetElevated,
+                 base::Unretained(this)));
   web_ui()->RegisterMessageCallback("extensionSettingsRequestExtensionsData",
       base::Bind(&ExtensionSettingsHandler::HandleRequestExtensionsData,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("extensionSettingsToggleDeveloperMode",
       base::Bind(&ExtensionSettingsHandler::HandleToggleDeveloperMode,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("extensionSettingsInspect",
       base::Bind(&ExtensionSettingsHandler::HandleInspectMessage,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("extensionSettingsLaunch",
@@ skipping 147 matching lines @@
     if ((*extension)->location() == Manifest::LOAD)
       unpacked_extensions.push_back(*extension);
   }
 
   for (std::vector<const Extension*>::iterator iter =
        unpacked_extensions.begin(); iter != unpacked_extensions.end(); ++iter) {
     extension_service_->ReloadExtension((*iter)->id());
   }
 }
 
+void ExtensionSettingsHandler::ManagedUserSetElevated(const ListValue* args) {
+  ManagedUserService* service = ManagedUserServiceFactory::GetForProfile(
+      Profile::FromWebUI(web_ui()));
+  bool elevated;
+  args->GetBoolean(0, &elevated);

[not at google - send to devlin, 2013/02/21 16:25:24]

CHECK(args->GetBoolean(..))

[Adrian Kuegel, 2013/02/21 16:39:00]

Done.

[Bernhard Bauer, 2013/02/21 17:35:40]

Do we really want a CHECK for untrusted input? It would mean that a compromised
renderer could crash the browser (cleanly, but it would still be a DOS attack).

[not at google - send to devlin, 2013/02/21 17:37:18]

it's chrome.send, that's not untrusted.

+  // TODO(akuegel): Show the managed user passphrase dialog for authentication
+  // if elevated should be set to true.
+  service->SetElevated(elevated);
+  HandleRequestExtensionsData(NULL);
+}
+
 void ExtensionSettingsHandler::HandleRequestExtensionsData(
     const ListValue* args) {
   DictionaryValue results;
 
   Profile* profile = Profile::FromWebUI(web_ui());
 
   // Add the extensions to the results structure.
   ListValue *extensions_list = new ListValue();
 
   extensions::ExtensionWarningService* warnings =
@@ skipping 25 matching lines @@
        extension != extensions->end(); ++extension) {
     if ((*extension)->ShouldDisplayInExtensionSettings()) {
       extensions_list->Append(CreateExtensionDetailValue(
           *extension,
           empty_pages,  // Terminated process has no active pages.
           warnings));
     }
   }
   results.Set("extensions", extensions_list);
 
-  bool is_managed =
-      ManagedUserServiceFactory::GetForProfile(profile)->ProfileIsManaged();
+  ManagedUserService* service =
+      ManagedUserServiceFactory::GetForProfile(profile);
+
+  bool is_managed = service->ProfileIsManaged();
+  bool is_elevated = service->IsElevated();
   bool developer_mode =
-      !is_managed &&
+      (!is_managed || is_elevated) &&
       profile->GetPrefs()->GetBoolean(prefs::kExtensionsUIDeveloperMode);
   results.SetBoolean("profileIsManaged", is_managed);
+  results.SetBoolean("profileIsElevated", service->IsElevated());
   results.SetBoolean("developerMode", developer_mode);
 
   // Check to see if we have any wiped out extensions.
   ExtensionService* extension_service =
       extensions::ExtensionSystem::Get(profile)->extension_service();
   scoped_ptr<const ExtensionSet> wiped_out(
       extension_service->GetWipedOutExtensions());
   results.SetBoolean("showDisabledExtensionsWarning", wiped_out->size() > 0);
 
   bool load_unpacked_disabled =
@@ skipping 433 matching lines @@
     std::vector<std::string> requirement_errors) {
   if (requirement_errors.empty()) {
     extension_service_->EnableExtension(extension_id);
   } else {
     ExtensionErrorReporter::GetInstance()->ReportError(
         UTF8ToUTF16(JoinString(requirement_errors, ' ')),
         true /* be noisy */);
   }
   requirements_checker_.reset();
 }