Import policy data into default search dictionary pref.

chrome/browser/search_engines/default_search_policy_handler.cc

 // Copyright 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/search_engines/default_search_policy_handler.h"
 
 #include "base/prefs/pref_value_map.h"
 #include "base/stl_util.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/search_engines/search_terms_data.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/common/pref_names.h"
 #include "components/policy/core/browser/policy_error_map.h"
 #include "components/policy/core/common/policy_map.h"
 #include "content/public/browser/notification_service.h"
 #include "grit/component_strings.h"
 #include "policy/policy_constants.h"
 
 namespace policy {
 
+// Keys for kDefaultSearchProviderData Pref.
+const char kID[] = "id";
+const char kShortName[] = "short_name";
+const char kKeyword[] = "keyword";
+const char kPrepopulateID[] = "prepopulate_id";
+const char kSyncGUID[] = "sync_guid";
+
+const char kURL[] = "url";
+const char kSuggestionsURL[] = "suggestions_url";
+const char kInstantURL[] = "instant_url";
+const char kImageURL[] = "image_url";
+const char kNewTabURL[] = "new_tab_url";
+const char kFaviconURL[] = "favicon_url";
+const char kOriginatingURL[] = "originating_url";
+
+const char kSearchURLPostParams[] = "search_url_post_params";
+const char kSuggestionsURLPostParams[] = "suggestions_url_post_params";
+const char kInstantURLPostParams[] = "instant_url_post_params";
+const char kImageURLPostParams[] = "image_url_post_params";
+
+const char kSafeForAutoReplace[] = "safe_for_autoreplace";
+const char kInputEncodings[] = "input_encodings";
+
+const char kDateCreated[] = "date_created";
+const char kLastModified[] = "last_modified";
+
+const char kUsageCount[] = "usage_count";
+const char kAlternateURLs[] = "alternate_urls";
+const char kSearchTermsReplacementKey[] = "search_terms_replacement_key";
+const char kCreatedByPolicy[] = "created_by_policy";

[gab, 2014/04/15 20:52:33]

We should avoid duplicating these again here (IIRC you have all of these strings
somewhere else; I assume they're identical?).

[Cait (Slow), 2014/04/16 21:14:11]

Done.

+
 // List of policy types to preference names, for policies affecting the default
 // search provider.
 const PolicyToPreferenceMapEntry kDefaultSearchPolicyMap[] = {
   { key::kDefaultSearchProviderEnabled,
     prefs::kDefaultSearchProviderEnabled,
     base::Value::TYPE_BOOLEAN },
   { key::kDefaultSearchProviderName,
     prefs::kDefaultSearchProviderName,
     base::Value::TYPE_STRING },
   { key::kDefaultSearchProviderKeyword,
@@ skipping 33 matching lines @@
     prefs::kDefaultSearchProviderSuggestURLPostParams,
     base::Value::TYPE_STRING },
   { key::kDefaultSearchProviderInstantURLPostParams,
     prefs::kDefaultSearchProviderInstantURLPostParams,
     base::Value::TYPE_STRING },
   { key::kDefaultSearchProviderImageURLPostParams,
     prefs::kDefaultSearchProviderImageURLPostParams,
     base::Value::TYPE_STRING },
 };
 
+// List of policy types to preference names, for policies affecting the default
+// search provider.
+const PolicyToPreferenceMapEntry kDefaultSearchPolicyDataMap[] = {
+  { key::kDefaultSearchProviderName,
+    kShortName,
+    base::Value::TYPE_STRING },
+  { key::kDefaultSearchProviderKeyword,
+    kKeyword,
+    base::Value::TYPE_STRING },
+  { key::kDefaultSearchProviderSearchURL,
+    kURL,
+    base::Value::TYPE_STRING },
+  { key::kDefaultSearchProviderSuggestURL,
+    kSuggestionsURL,
+    base::Value::TYPE_STRING },
+  { key::kDefaultSearchProviderInstantURL,
+    kInstantURL,
+    base::Value::TYPE_STRING },
+  { key::kDefaultSearchProviderIconURL,
+    kFaviconURL,
+    base::Value::TYPE_STRING },
+  { key::kDefaultSearchProviderEncodings,
+    kInputEncodings,
+    base::Value::TYPE_LIST },
+  { key::kDefaultSearchProviderAlternateURLs,
+    kAlternateURLs,
+    base::Value::TYPE_LIST },
+  { key::kDefaultSearchProviderSearchTermsReplacementKey,
+    kSearchTermsReplacementKey,
+    base::Value::TYPE_STRING },
+  { key::kDefaultSearchProviderImageURL,
+    kImageURL,
+    base::Value::TYPE_STRING },
+  { key::kDefaultSearchProviderNewTabURL,
+    kNewTabURL,
+    base::Value::TYPE_STRING },
+  { key::kDefaultSearchProviderSearchURLPostParams,
+    kSearchURLPostParams,
+    base::Value::TYPE_STRING },
+  { key::kDefaultSearchProviderSuggestURLPostParams,
+    kSuggestionsURLPostParams,
+    base::Value::TYPE_STRING },
+  { key::kDefaultSearchProviderInstantURLPostParams,
+    kInstantURLPostParams,
+    base::Value::TYPE_STRING },
+  { key::kDefaultSearchProviderImageURLPostParams,
+    kImageURLPostParams,
+    base::Value::TYPE_STRING },
+};
+
+

[gab, 2014/04/15 20:52:33]

nit: rm extra empty line

[Cait (Slow), 2014/04/16 21:14:11]

Done.

 // DefaultSearchEncodingsPolicyHandler implementation --------------------------
 
 DefaultSearchEncodingsPolicyHandler::DefaultSearchEncodingsPolicyHandler()
     : TypeCheckingPolicyHandler(key::kDefaultSearchProviderEncodings,
                                 base::Value::TYPE_LIST) {}
 
 DefaultSearchEncodingsPolicyHandler::~DefaultSearchEncodingsPolicyHandler() {
 }
 
 void DefaultSearchEncodingsPolicyHandler::ApplyPolicySettings(
@@ skipping 65 matching lines @@
   const base::Value* url;
   std::string dummy;
   if (DefaultSearchURLIsValid(policies, &url, &dummy) ||
       !AnyDefaultSearchPoliciesSpecified(policies))
     return true;
   errors->AddError(key::kDefaultSearchProviderSearchURL, url ?
       IDS_POLICY_INVALID_SEARCH_URL_ERROR : IDS_POLICY_NOT_SPECIFIED_ERROR);
   return false;
 }
 
+void SetListInPref(const PolicyMap& policies, base::DictionaryValue* dict,

[gab, 2014/04/15 20:52:33]

out-param last

[Cait (Slow), 2014/04/16 21:14:11]

Done.

+    const char* policy_name, const char* key) {
+  const base::Value* value = policies.GetValue(policy_name);
+  const base::ListValue* list = new base::ListValue();
+  if (value)
+    value->GetAsList(&list);

[gab, 2014/04/15 20:52:33]

I would prefer to check that this is indeed a list (and be prepared if it isn't
one -- as this method is called based on the expected type, not the type that
was actually read).

Also, this will leak the |list| you created above if GetAsList() succeeds.

I instead suggest something like:

const base::Value* policy_value = policies.GetValue(policy_name);
const base::ListValue* policy_list = NULL;
if (policy_value) {
  bool is_list = value->GetAsList(&policy_list);
  DCHECK(is_list);
}

dict->Set(key, policy_list ? policy_list->DeepCopy() : new base::ListValue());

[Cait (Slow), 2014/04/16 21:14:11]

Done.

+  dict->Set(key, list->DeepCopy());
+}
+
+void SetStringInPref(const PolicyMap& policies, base::DictionaryValue* dict,
+    const char* policy_name, const char* key) {
+  const base::Value* value = policies.GetValue(policy_name);
+  std::string str = std::string();

[gab, 2014/04/15 20:52:33]

No need to explicitly initialize:

std::string str;

is equivalent.

[Cait (Slow), 2014/04/16 21:14:11]

Done.

+  if (value)
+    value->GetAsString(&str);

[gab, 2014/04/15 20:52:33]

DCHECK return value.

[Cait (Slow), 2014/04/16 21:14:11]

Done.

+  dict->SetString(key, str);
+}
+
+void DefaultSearchPolicyHandler::HandleDictionaryPref(const PolicyMap& policies,
+                                                      PrefValueMap* prefs) {
+  TemplateURLData data;
+  if (DefaultSearchProviderIsDisabled(policies)) {
+    // Set data to default values.

[gab, 2014/04/15 20:52:33]

TODO?

[Cait (Slow), 2014/04/16 21:14:11]

Done.

+  } else {
+    // The search URL is required.  The other entries are optional.  Just make
+    // sure that they are all specified via policy, so that the regular prefs
+    // aren't used.
+    const base::Value* dummy;
+    std::string url;
+    if (!DefaultSearchURLIsValid(policies, &dummy, &url))
+      return;
+
+    base::DictionaryValue* dict = new base::DictionaryValue;
+    for (size_t i = 0; i < arraysize(kDefaultSearchPolicyDataMap); ++i) {
+      const char* policy_name = kDefaultSearchPolicyDataMap[i].policy_name;
+      switch (kDefaultSearchPolicyDataMap[i].value_type) {
+        case base::Value::TYPE_STRING:
+          SetStringInPref(policies, dict, policy_name,
+              kDefaultSearchPolicyDataMap[i].preference_path);
+          break;
+        case base::Value::TYPE_LIST:
+          SetListInPref(policies, dict, policy_name,
+              kDefaultSearchPolicyDataMap[i].preference_path);
+          break;
+      }

[gab, 2014/04/15 20:52:33]

Clang will complain about not all cases being handled.

Add a 
default: 
  NOTREACHED(); 
  break;
block.

[Cait (Slow), 2014/04/16 21:14:11]

Done.

+    }
+    dict->SetString(kID, base::Int64ToString(kInvalidTemplateURLID));
+    dict->SetInteger(kPrepopulateID, 0);
+    dict->SetString(kSyncGUID, std::string());
+    dict->SetString(kOriginatingURL, std::string());

[gab, 2014/04/15 20:52:33]

Add comments where necessary above/below for the reasoning behind these
hardcoded values.

[Cait (Slow), 2014/04/16 21:14:11]

These may go away if we decide there's no point in setting them here. I've added
a todo to add comments or remove hardcoding.

+
+    dict->SetBoolean(kSafeForAutoReplace, true);
+
+    dict->SetDouble(kDateCreated, base::Time::Now().ToInternalValue());
+    dict->SetDouble(kLastModified, base::Time::Now().ToInternalValue());
+    dict->SetInteger(kUsageCount, 0);
+    dict->SetBoolean(kCreatedByPolicy, true);
+
+    // For the name and keyword, default to the host if not specified.  If
+    // there is no host (file: URLs?  Not sure), use "_" to guarantee that the
+    // keyword is non-empty.
+    std::string name, keyword;
+    dict->GetString(kKeyword, &keyword);
+    dict->GetString(kShortName, &name);
+    dict->GetString(kURL, &url);
+    std::string host(GURL(url).host());
+    if (host.empty())
+      host = "_";
+    if (name.empty())
+      dict->SetString(kShortName, host);
+    if (keyword.empty())
+      dict->SetString(kKeyword, host);
+
+    prefs->SetValue(prefs::kDefaultSearchProviderData, dict);
+  }
+}
+
 void DefaultSearchPolicyHandler::ApplyPolicySettings(const PolicyMap& policies,
                                                      PrefValueMap* prefs) {
+  HandleDictionaryPref(policies, prefs);
+
   if (DefaultSearchProviderIsDisabled(policies)) {
     prefs->SetBoolean(prefs::kDefaultSearchProviderEnabled, false);
 
     // If default search is disabled, the other fields are ignored.
     prefs->SetString(prefs::kDefaultSearchProviderName, std::string());
     prefs->SetString(prefs::kDefaultSearchProviderSearchURL, std::string());
     prefs->SetString(prefs::kDefaultSearchProviderSuggestURL, std::string());
     prefs->SetString(prefs::kDefaultSearchProviderIconURL, std::string());
     prefs->SetString(prefs::kDefaultSearchProviderEncodings, std::string());
     prefs->SetString(prefs::kDefaultSearchProviderKeyword, std::string());
@@ skipping 142 matching lines @@
 void DefaultSearchPolicyHandler::EnsureListPrefExists(
     PrefValueMap* prefs,
     const std::string& path) {
   base::Value* value;
   base::ListValue* list_value;
   if (!prefs->GetValue(path, &value) || !value->GetAsList(&list_value))
     prefs->SetValue(path, new base::ListValue());
 }
 
 }  // namespace policy