Create interface to manage manual exceptions.

chrome/browser/ui/webui/options/managed_user_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/options/managed_user_settings_handler.h"
 
+#include <vector>
+
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/time.h"
 #include "base/values.h"
 #include "chrome/browser/first_run/first_run.h"
+#include "chrome/browser/managed_mode/managed_user_service.h"
+#include "chrome/browser/managed_mode/managed_user_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_ui.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/google_chrome_strings.h"
 #include "grit/locale_settings.h"
 
 using content::UserMetricsAction;
 
+namespace {
+
+const char* kSetting = "setting";
+const char* kPattern = "pattern";
+
+// Create a DictionaryValue that will act as a row in the pattern list.
+// Ownership of the pointer is passed to the caller.
+DictionaryValue* GetEntryForPattern(const std::string pattern,
+                                    const std::string setting) {
+  base::DictionaryValue* entry = new base::DictionaryValue();
+  entry->SetString(kPattern, pattern);
+  entry->SetString(kSetting, setting);
+  return entry;
+}
+
+// Read the manual url and host lists from the current profile and add them to
+// the list of |entries|.
+void AddCurrentURLEntries(content::WebUI* web_ui, ListValue* entries) {
+  Profile* profile = Profile::FromWebUI(web_ui);
+  const DictionaryValue* dict =
+      profile->GetPrefs()->GetDictionary(prefs::kManagedModeManualHosts);
+  for (DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance()) {
+    bool allow = false;
+    bool result = it.value().GetAsBoolean(&allow);
+    DCHECK(result);
+    entries->Append(
+        GetEntryForPattern(it.key(), allow ? "allow" : "block"));
+  }
+
+  dict = profile->GetPrefs()->GetDictionary(prefs::kManagedModeManualURLs);
+  for (DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance()) {
+    bool allow = false;
+    bool result = it.value().GetAsBoolean(&allow);
+    DCHECK(result);
+    entries->Append(
+        GetEntryForPattern(it.key(), allow ? "allow" : "block"));
+  }
+}
+
+}  // namespace
+
 namespace options {
 
 ManagedUserSettingsHandler::ManagedUserSettingsHandler() {
 }
 
 ManagedUserSettingsHandler::~ManagedUserSettingsHandler() {
 }
 
 void ManagedUserSettingsHandler::InitializeHandler() {
   pref_change_registrar_.Init(Profile::FromWebUI(web_ui())->GetPrefs());
   pref_change_registrar_.Add(
       prefs::kManagedModeLocalPassphrase,
       base::Bind(&ManagedUserSettingsHandler::OnLocalPassphraseChanged,
                  base::Unretained(this)));
 }
 
 void ManagedUserSettingsHandler::InitializePage() {
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableManagedUsers)) {
     PrefService* pref_service = Profile::FromWebUI(web_ui())->GetPrefs();
     base::FundamentalValue is_passphrase_set(!pref_service->GetString(
         prefs::kManagedModeLocalPassphrase).empty());
     web_ui()->CallJavascriptFunction(
         "ManagedUserSettings.passphraseChanged",
         is_passphrase_set);
   }
+
+  // Populate the list.
+  UpdateViewFromModel();
 }
 
 void ManagedUserSettingsHandler::HandlePageOpened(const base::ListValue* args) {
   start_time_ = base::TimeTicks::Now();
   content::RecordAction(UserMetricsAction("ManagedMode_OpenSettings"));
 }
 
 void ManagedUserSettingsHandler::GetLocalizedValues(
     base::DictionaryValue* localized_strings) {
   DCHECK(localized_strings);
 
   static OptionsStringResource resources[] = {
     // Unlock the settings page to allow editing.
     { "unlockSettings", IDS_UNLOCK_PASSPHRASE_BUTTON },
     { "lockSettings", IDS_LOCK_MANAGED_USER_BUTTON },
+    // Manual exception view.
+    { "allowException", IDS_EXCEPTIONS_ALLOW_BUTTON },
+    { "blockException", IDS_EXCEPTIONS_BLOCK_BUTTON },
+    { "addNewExceptionInstructions", IDS_EXCEPTIONS_ADD_NEW_INSTRUCTIONS },
+    { "manageExceptions", IDS_EXCEPTIONS_MANAGE },
+    { "exceptionPatternHeader", IDS_EXCEPTIONS_PATTERN_HEADER },
+    { "exceptionBehaviorHeader", IDS_EXCEPTIONS_ACTION_HEADER },
     // Installed content packs.
-    { "installedContentPacks", IDS_INSTALLED_CONTENT_PACKS_LABEL },
+    { "manualExceptionsHeader", IDS_MANUAL_EXCEPTION_HEADER },
+    { "manualExceptionsTabTitle", IDS_MANUAL_EXCEPTION_TAB_TITLE },
+    { "contentPacksTabLabel", IDS_CONTENT_PACKS_TAB_LABEL },
     { "getContentPacks", IDS_GET_CONTENT_PACKS_BUTTON },
     { "getContentPacksURL", IDS_GET_CONTENT_PACKS_URL },
     // Content pack restriction options.
     { "contentPackSettings", IDS_CONTENT_PACK_SETTINGS_LABEL },
     { "outsideContentPacksAllow", IDS_OUTSIDE_CONTENT_PACKS_ALLOW_RADIO },
     { "outsideContentPacksWarn", IDS_OUTSIDE_CONTENT_PACKS_WARN_RADIO },
     { "outsideContentPacksBlock", IDS_OUTSIDE_CONTENT_PACKS_BLOCK_RADIO },
     // Other managed user settings
     { "advancedManagedUserSettings", IDS_ADVANCED_MANAGED_USER_LABEL },
     { "enableSafeSearch", IDS_SAFE_SEARCH_ENABLED },
     { "allowSignIn", IDS_SIGNIN_SYNC_ALLOWED },
     { "disableHistoryDeletion", IDS_HISTORY_DELETION_DISABLED },
     { "usePassphrase", IDS_USE_PASSPHRASE_LABEL },
     { "setPassphrase", IDS_SET_PASSPHRASE_BUTTON }
   };
 
   RegisterStrings(localized_strings, resources, arraysize(resources));
   RegisterTitle(localized_strings, "managedUserSettingsPage",
                 IDS_MANAGED_USER_SETTINGS_TITLE);
-
+  RegisterTitle(localized_strings, "manualExceptions",
+                IDS_MANUAL_EXCEPTION_HEADER);
   localized_strings->SetBoolean(
       "managedUsersEnabled",
       CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableManagedUsers));
 }
 
 void ManagedUserSettingsHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       "confirmManagedUserSettings",
       base::Bind(&ManagedUserSettingsHandler::SaveMetrics,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "settingsPageOpened",
       base::Bind(&ManagedUserSettingsHandler::HandlePageOpened,
                  base::Unretained(this)));
+  web_ui()->RegisterMessageCallback("removeManualException",
+      base::Bind(&ManagedUserSettingsHandler::RemoveManualException,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback("setManualException",
+      base::Bind(&ManagedUserSettingsHandler::SetManualException,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback("checkManualExceptionValidity",
+      base::Bind(
+      &ManagedUserSettingsHandler::CheckManualExceptionValidity,
+                 base::Unretained(this)));
 }
 
 void ManagedUserSettingsHandler::SaveMetrics(const ListValue* args) {
   if (first_run::IsChromeFirstRun()) {
     UMA_HISTOGRAM_LONG_TIMES("ManagedMode.UserSettingsFirstRunTime",
                              base::TimeTicks::Now() - start_time_);
   } else {
     UMA_HISTOGRAM_LONG_TIMES("ManagedMode.UserSettingsModifyTime",
                              base::TimeTicks::Now() - start_time_);
   }
 }
 
 void ManagedUserSettingsHandler::OnLocalPassphraseChanged() {
   PrefService* pref_service = Profile::FromWebUI(web_ui())->GetPrefs();
   base::FundamentalValue is_passphrase_set(!pref_service->GetString(
       prefs::kManagedModeLocalPassphrase).empty());
   web_ui()->CallJavascriptFunction("ManagedUserSettings.passphraseChanged",
                                    is_passphrase_set);
 }
 
+void ManagedUserSettingsHandler::RemoveManualException(
+    const ListValue* args) {
+  size_t arg_i = 0;
+  std::string pattern;
+  CHECK(args->GetString(arg_i++, &pattern));
+
+  UpdateManualBehavior(pattern, ManagedUserService::MANUAL_NONE);
+
+  UpdateViewFromModel();
+}
+
+void ManagedUserSettingsHandler::UpdateManualBehavior(
+    std::string pattern,
+    ManagedUserService::ManualBehavior behavior) {
+  ManagedUserService* service =
+      ManagedUserServiceFactory::GetForProfile(Profile::FromWebUI(web_ui()));
+  GURL url(pattern);
+  if (!url.is_valid()) {
+    // This is a host pattern.
+    std::vector<std::string> to_update;
+    to_update.push_back(pattern);
+    service->SetManualBehaviorForHosts(to_update, behavior);
+  } else {
+    // A specific URL.
+    std::vector<GURL> to_update;
+    to_update.push_back(url);
+    service->SetManualBehaviorForURLs(to_update, behavior);
+  }
+}
+
+void ManagedUserSettingsHandler::SetManualException(
+    const ListValue* args) {
+  size_t arg_i = 0;
+  std::string pattern;
+  CHECK(args->GetString(arg_i++, &pattern));
+  std::string setting;
+  CHECK(args->GetString(arg_i++, &setting));
+  bool needs_update;
+  CHECK(args->GetBoolean(arg_i++, &needs_update));
+
+  DCHECK(setting == "allow" || setting == "block");
+  ManagedUserService::ManualBehavior behavior =
+      (setting == "allow") ? ManagedUserService::MANUAL_ALLOW
+                           : ManagedUserService::MANUAL_BLOCK;
+  UpdateManualBehavior(pattern, behavior);
+
+  if (needs_update)
+    UpdateViewFromModel();
+}
+
+void ManagedUserSettingsHandler::CheckManualExceptionValidity(
+    const ListValue* args) {
+  size_t arg_i = 0;
+  std::string pattern_string;
+  CHECK(args->GetString(arg_i++, &pattern_string));
+  bool is_valid = false;
+
+  // First, try to see if it is a valid URL.
+  GURL url(pattern_string);
+  is_valid = url.is_valid() && url.IsStandard();
+
+  // If it's not valid, try to put a http:// schema to it. If it was a host, it
+  // should be valid now, but check that the path, query and ref are empty.
+  if (!is_valid) {
+    url = GURL("http://" + pattern_string);
+    is_valid = url.is_valid() && url.path() == "/" && !url.has_query() &&
+               !url.has_ref();

[Bernhard Bauer, 2013/03/27 14:41:11]

How about using CanonicalizeHost() (from gurl.h)? It will return false for an
invalid host, and as a bonus you'll get a nice canonicalized hostname back.

[Sergiu, 2013/03/27 15:26:46]

I've changed it to that (the one from url_canon.h) but I'm not sure we want to
show the user the canonical version, that one is escaped.

[Bernhard Bauer, 2013/03/27 15:55:12]

By escaped you mean punycode? We also use that in any other place I can think of
(e.g. history, omnibox).

We also use canonicalized hostnames internally in ManagedUserService, so that's
what we should pass to it. If we really want to show the hosts unescaped, we
should do that just for the UI.

+  }
+
+  web_ui()->CallJavascriptFunction(
+      "ManagedUserSettings.patternValidityCheckComplete",
+      base::StringValue(pattern_string),
+      base::FundamentalValue(is_valid));
+}
+
+void ManagedUserSettingsHandler::UpdateViewFromModel() {
+  ListValue entries;
+  AddCurrentURLEntries(web_ui(), &entries);
+
+  web_ui()->CallJavascriptFunction(
+      "ManagedUserSettings.setManualExceptions",
+      entries);
+}
+
 }  // namespace options