Add a lock to the managed user settings page and require authentication for unlocking.

chrome/browser/managed_mode/managed_mode.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/managed_mode/managed_mode.h"
 
 #include "base/command_line.h"
 #include "base/prefs/public/pref_change_registrar.h"
 #include "base/sequenced_task_runner.h"
 #include "chrome/browser/browser_process.h"
@@ skipping 99 matching lines @@
 
 // static
 void ManagedMode::RegisterUserPrefs(PrefServiceSyncable* prefs) {
   prefs->RegisterIntegerPref(prefs::kDefaultManagedModeFilteringBehavior,
                              2,
                              PrefServiceSyncable::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kManagedModeWhitelist,
                           PrefServiceSyncable::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kManagedModeBlacklist,
                           PrefServiceSyncable::UNSYNCABLE_PREF);
+  prefs->RegisterStringPref(prefs::kManagedModeLocalPassphrase,
+                            "",
+                            PrefServiceSyncable::UNSYNCABLE_PREF);
+  prefs->RegisterStringPref(prefs::kManagedModeLocalSalt,
+                            "",
+                            PrefServiceSyncable::UNSYNCABLE_PREF);
 }
 
 // static
 void ManagedMode::Init(Profile* profile) {
   GetInstance()->InitImpl(profile);
 }
 
 void ManagedMode::InitImpl(Profile* profile) {
   DCHECK(g_browser_process);
   DCHECK(g_browser_process->local_state());
 
   Profile* original_profile = profile->GetOriginalProfile();
   // Set the value directly in the PrefService instead of using
   // CommandLinePrefStore so we can change it at runtime.
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kNoManaged)) {
     SetInManagedMode(NULL);
   } else if (IsInManagedModeImpl() ||
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kManaged)) {
     SetInManagedMode(original_profile);
   }
 }
 
 // static
 bool ManagedMode::IsInManagedMode() {
   return GetInstance()->IsInManagedModeImpl();
 }
 
+// static
+bool ManagedMode::IsCustodianAuthenticated() {
+  if (GetInstance()->managed_profile_) {
+    PrefService* pref_service = GetInstance()->managed_profile_->GetPrefs();
+    if (pref_service->GetString(prefs::kManagedModeLocalPassphrase).empty())
+      return true;
+  }
+  return GetInstance()->is_custodian_authenticated_;
+}
+
+// static
+void ManagedMode::SetCustodianAuthenticated(bool isAuthenticated) {
+  GetInstance()->is_custodian_authenticated_ = isAuthenticated;
+}
+
 bool ManagedMode::IsInManagedModeImpl() const {
   // |g_browser_process| can be NULL during startup.
   if (!g_browser_process)
     return false;
   // Local State can be NULL during unit tests.
   if (!g_browser_process->local_state())
     return false;
   return g_browser_process->local_state()->GetBoolean(prefs::kInManagedMode);
 }
 
@@ skipping 220 matching lines @@
     return;
   }
   size_t count = browsers_to_close_.erase(browser);
   DCHECK_EQ(1u, count);
   if (browsers_to_close_.empty())
     FinalizeEnter(true);
 }
 
 ManagedMode::ManagedMode()
     : managed_profile_(NULL),
+      is_custodian_authenticated_(false),
       io_url_filter_context_(
           new URLFilterContext(
               BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO))),
       ui_url_filter_context_(
           new URLFilterContext(
               BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI))) {
   BrowserList::AddObserver(this);
 }
 
 ManagedMode::~ManagedMode() {
@@ skipping 130 matching lines @@
       managed_profile_->GetPrefs()->GetList(
           prefs::kManagedModeWhitelist)->DeepCopy());
 }
 
 void ManagedMode::AddURLPatternToManualList(
     bool is_whitelist,
     const std::string& url_pattern) {
   io_url_filter_context_->AddURLPatternToManualList(true, url_pattern);
   ui_url_filter_context_->AddURLPatternToManualList(true, url_pattern);
 }