Initial Managed Mode extension API, supporting querying the setting and a stub for enabling the mod…

chrome/browser/extensions/extension_managed_mode_api.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.
+
+// Implementation of the Chrome Extensions Managed Mode API.
+
+#include "chrome/browser/extensions/extension_managed_mode_api.h"
+
+#include <string>
+
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/extensions/extension_preference_api_constants.h"
+#include "chrome/browser/prefs/pref_service.h"

[Bernhard Bauer, 2012/03/01 16:32:14]

Nit: Remove one empty line here, but add empty lines between the namespace
declaration? :-)

+
+
+namespace {
+// Extension-pref key corresponding to the kInManagedMode browser pref.
+const char kManagedModeEnabledKey[] = "managedModeEnabled";
+
+// Key to report whether the attempt to enable managed mode succeeded.
+const char kEnableSuccessKey[] = "success";
+}  // namespace
+
+namespace keys = extension_preference_api_constants;
+
+GetManagedModeFunction::~GetManagedModeFunction() { }
+
+bool GetManagedModeFunction::RunImpl() {
+  std::string browser_pref;
+  if (!ValidateBrowserPref(kManagedModeEnabledKey, &browser_pref))

[Bernhard Bauer, 2012/03/01 16:32:14]

What does it mean when this check fails? The key is a constant, so it should be
fine, and the ExtensionFunctionDispatcher (I think) should already check whether
we have the permission (we only have to do it manually for other preference
functions, because they're used by ChromeSettings with different permissions).

+    return false;
+  PrefService* local_state = g_browser_process->local_state();
+  bool enabled = local_state->GetBoolean(browser_pref.c_str());

[Bernhard Bauer, 2012/03/01 16:32:14]

Hm, thinking about it, we could directly use the pref key here, no?

+
+  // Since only one managed-mode extension can be active at a time, this
+  // extension can control the value iff it is not currently enabled.
+  // (This will need to be fixed if we ever have a policy or command-line
+  // switch to prohibit managed mode.)
+  std::string level_of_control = enabled ? keys::kNotControllable

[Bernhard Bauer, 2012/03/01 16:32:14]

I'm not sure if this makes anything clearer to the extension :-D The mechanism
for setting local state prefs works differently than for user prefs in any case
(as there is no controlling extension in that sense).

[Pam (message me for reviews), 2012/03/01 20:47:34]

My goal was to keep the get() method as close to the one from ChromeSettings as
makes sense. It's conceivable we could have a policy that prohibits managed
mode, in which case "not_controllable" would become meaningful and distinct from
"enabled". I felt it was worth keeping levelOfControl around just in case it
became useful. That requires putting *something* into it, and this was the best
match. 

[Bernhard Bauer, 2012/03/02 09:23:58]

OK. We still might to think about what controllable etc. mean here though.

+                                         : keys::kControllableByThisExtension;
+
+  scoped_ptr<DictionaryValue> result(new DictionaryValue);
+  result->SetBoolean(keys::kValue, enabled);
+  result->SetString(keys::kLevelOfControl, level_of_control);
+  result_.reset(result.release());
+  return true;
+}
+
+EnableManagedModeFunction::~EnableManagedModeFunction() { }
+
+bool EnableManagedModeFunction::RunImpl() {
+  std::string browser_pref;
+  if (!ValidateBrowserPref(kManagedModeEnabledKey, &browser_pref))
+    return false;
+  PrefService* local_state = g_browser_process->local_state();
+  bool enabled = local_state->GetBoolean(browser_pref.c_str());
+
+  bool confirmed = true;
+  if (!enabled) {
+    // TODO(pamg): WIP. Show modal password dialog and save hashed password. Set
+    //     callback_result to false if user cancels dialog.
+
+    if (confirmed)
+      local_state->SetBoolean(browser_pref.c_str(), true);
+  }
+
+  scoped_ptr<DictionaryValue> result(new DictionaryValue);
+  result->SetBoolean(kEnableSuccessKey, confirmed);
+  result_.reset(result.release());
+  return true;
+}