components/search_engines/default_search_manager.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/search_engines/default_search_manager.h"
   6
   7 #include <algorithm>
   8 #include <utility>
   9
  10 #include "base/bind.h"
  11 #include "base/bind_helpers.h"
  12 #include "base/compiler_specific.h"
  13 #include "base/i18n/case_conversion.h"
  14 #include "base/logging.h"
  15 #include "base/prefs/pref_service.h"
  16 #include "base/prefs/pref_value_map.h"
  17 #include "base/stl_util.h"
  18 #include "base/strings/string_number_conversions.h"
  19 #include "base/strings/string_split.h"
  20 #include "base/strings/string_util.h"
  21 #include "base/strings/utf_string_conversions.h"
  22 #include "base/time/time.h"
  23 #include "components/pref_registry/pref_registry_syncable.h"
  24 #include "components/search_engines/search_engines_pref_names.h"
  25 #include "components/search_engines/template_url_data.h"
  26 #include "components/search_engines/template_url_prepopulate_data.h"
  27
  28 namespace {
  29
  30 bool g_fallback_search_engines_disabled = false;
  31
  32 }  // namespace
  33
  34 // A dictionary to hold all data related to the Default Search Engine.
  35 // Eventually, this should replace all the data stored in the
  36 // default_search_provider.* prefs.
  37 const char DefaultSearchManager::kDefaultSearchProviderDataPrefName[] =
  38     "default_search_provider_data.template_url_data";
  39
  40 const char DefaultSearchManager::kID[] = "id";
  41 const char DefaultSearchManager::kShortName[] = "short_name";
  42 const char DefaultSearchManager::kKeyword[] = "keyword";
  43 const char DefaultSearchManager::kPrepopulateID[] = "prepopulate_id";
  44 const char DefaultSearchManager::kSyncGUID[] = "synced_guid";
  45
  46 const char DefaultSearchManager::kURL[] = "url";
  47 const char DefaultSearchManager::kSuggestionsURL[] = "suggestions_url";
  48 const char DefaultSearchManager::kInstantURL[] = "instant_url";
  49 const char DefaultSearchManager::kImageURL[] = "image_url";
  50 const char DefaultSearchManager::kNewTabURL[] = "new_tab_url";
  51 const char DefaultSearchManager::kFaviconURL[] = "favicon_url";
  52 const char DefaultSearchManager::kOriginatingURL[] = "originating_url";
  53
  54 const char DefaultSearchManager::kSearchURLPostParams[] =
  55     "search_url_post_params";
  56 const char DefaultSearchManager::kSuggestionsURLPostParams[] =
  57     "suggestions_url_post_params";
  58 const char DefaultSearchManager::kInstantURLPostParams[] =
  59     "instant_url_post_params";
  60 const char DefaultSearchManager::kImageURLPostParams[] =
  61     "image_url_post_params";
  62
  63 const char DefaultSearchManager::kSafeForAutoReplace[] = "safe_for_autoreplace";
  64 const char DefaultSearchManager::kInputEncodings[] = "input_encodings";
  65
  66 const char DefaultSearchManager::kDateCreated[] = "date_created";
  67 const char DefaultSearchManager::kLastModified[] = "last_modified";
  68
  69 const char DefaultSearchManager::kUsageCount[] = "usage_count";
  70 const char DefaultSearchManager::kAlternateURLs[] = "alternate_urls";
  71 const char DefaultSearchManager::kSearchTermsReplacementKey[] =
  72     "search_terms_replacement_key";
  73 const char DefaultSearchManager::kCreatedByPolicy[] = "created_by_policy";
  74 const char DefaultSearchManager::kDisabledByPolicy[] = "disabled_by_policy";
  75
  76 DefaultSearchManager::DefaultSearchManager(
  77     PrefService* pref_service,
  78     const ObserverCallback& change_observer)
  79     : pref_service_(pref_service),
  80       change_observer_(change_observer),
  81       default_search_controlled_by_policy_(false) {
  82   if (pref_service_) {
  83     pref_change_registrar_.Init(pref_service_);
  84     pref_change_registrar_.Add(
  85         kDefaultSearchProviderDataPrefName,
  86         base::Bind(&DefaultSearchManager::OnDefaultSearchPrefChanged,
  87                    base::Unretained(this)));
  88     pref_change_registrar_.Add(
  89         prefs::kSearchProviderOverrides,
  90         base::Bind(&DefaultSearchManager::OnOverridesPrefChanged,
  91                    base::Unretained(this)));
  92   }
  93   LoadPrepopulatedDefaultSearch();
  94   LoadDefaultSearchEngineFromPrefs();
  95 }
  96
  97 DefaultSearchManager::~DefaultSearchManager() {
  98 }
  99
 100 // static
 101 void DefaultSearchManager::RegisterProfilePrefs(
 102     user_prefs::PrefRegistrySyncable* registry) {
 103   registry->RegisterDictionaryPref(kDefaultSearchProviderDataPrefName);
 104 }
 105
 106 // static
 107 void DefaultSearchManager::AddPrefValueToMap(base::DictionaryValue* value,
 108                                              PrefValueMap* pref_value_map) {
 109   pref_value_map->SetValue(kDefaultSearchProviderDataPrefName, value);
 110 }
 111
 112 // static
 113 void DefaultSearchManager::SetFallbackSearchEnginesDisabledForTesting(
 114     bool disabled) {
 115   g_fallback_search_engines_disabled = disabled;
 116 }
 117
 118 TemplateURLData* DefaultSearchManager::GetDefaultSearchEngine(
 119     Source* source) const {
 120   if (default_search_controlled_by_policy_) {
 121     if (source)
 122       *source = FROM_POLICY;
 123     return prefs_default_search_.get();
 124   }
 125   if (extension_default_search_) {
 126     if (source)
 127       *source = FROM_EXTENSION;
 128     return extension_default_search_.get();
 129   }
 130   if (prefs_default_search_) {
 131     if (source)
 132       *source = FROM_USER;
 133     return prefs_default_search_.get();
 134   }
 135
 136   if (source)
 137     *source = FROM_FALLBACK;
 138   return g_fallback_search_engines_disabled ?
 139       NULL : fallback_default_search_.get();
 140 }
 141
 142 DefaultSearchManager::Source
 143 DefaultSearchManager::GetDefaultSearchEngineSource() const {
 144   Source source;
 145   GetDefaultSearchEngine(&source);
 146   return source;
 147 }
 148
 149 void DefaultSearchManager::SetUserSelectedDefaultSearchEngine(
 150     const TemplateURLData& data) {
 151   if (!pref_service_) {
 152     prefs_default_search_.reset(new TemplateURLData(data));
 153     MergePrefsDataWithPrepopulated();
 154     NotifyObserver();
 155     return;
 156   }
 157
 158   base::DictionaryValue url_dict;
 159   url_dict.SetString(kID, base::Int64ToString(data.id));
 160   url_dict.SetString(kShortName, data.short_name());
 161   url_dict.SetString(kKeyword, data.keyword());
 162   url_dict.SetInteger(kPrepopulateID, data.prepopulate_id);
 163   url_dict.SetString(kSyncGUID, data.sync_guid);
 164
 165   url_dict.SetString(kURL, data.url());
 166   url_dict.SetString(kSuggestionsURL, data.suggestions_url);
 167   url_dict.SetString(kInstantURL, data.instant_url);
 168   url_dict.SetString(kImageURL, data.image_url);
 169   url_dict.SetString(kNewTabURL, data.new_tab_url);
 170   url_dict.SetString(kFaviconURL, data.favicon_url.spec());
 171   url_dict.SetString(kOriginatingURL, data.originating_url.spec());
 172
 173   url_dict.SetString(kSearchURLPostParams, data.search_url_post_params);
 174   url_dict.SetString(kSuggestionsURLPostParams,
 175                      data.suggestions_url_post_params);
 176   url_dict.SetString(kInstantURLPostParams, data.instant_url_post_params);
 177   url_dict.SetString(kImageURLPostParams, data.image_url_post_params);
 178
 179   url_dict.SetBoolean(kSafeForAutoReplace, data.safe_for_autoreplace);
 180
 181   url_dict.SetString(kDateCreated,
 182                      base::Int64ToString(data.date_created.ToInternalValue()));
 183   url_dict.SetString(kLastModified,
 184                      base::Int64ToString(data.last_modified.ToInternalValue()));
 185   url_dict.SetInteger(kUsageCount, data.usage_count);
 186
 187   scoped_ptr<base::ListValue> alternate_urls(new base::ListValue);
 188   for (std::vector<std::string>::const_iterator it =
 189            data.alternate_urls.begin();
 190        it != data.alternate_urls.end(); ++it) {
 191     alternate_urls->AppendString(*it);
 192   }
 193   url_dict.Set(kAlternateURLs, alternate_urls.release());
 194
 195   scoped_ptr<base::ListValue> encodings(new base::ListValue);
 196   for (std::vector<std::string>::const_iterator it =
 197            data.input_encodings.begin();
 198        it != data.input_encodings.end(); ++it) {
 199     encodings->AppendString(*it);
 200   }
 201   url_dict.Set(kInputEncodings, encodings.release());
 202
 203   url_dict.SetString(kSearchTermsReplacementKey,
 204                      data.search_terms_replacement_key);
 205
 206   url_dict.SetBoolean(kCreatedByPolicy, data.created_by_policy);
 207
 208   pref_service_->Set(kDefaultSearchProviderDataPrefName, url_dict);
 209 }
 210
 211 void DefaultSearchManager::SetExtensionControlledDefaultSearchEngine(
 212     const TemplateURLData& data) {
 213   extension_default_search_.reset(new TemplateURLData(data));
 214   if (GetDefaultSearchEngineSource() == FROM_EXTENSION)
 215     NotifyObserver();
 216 }
 217
 218 void DefaultSearchManager::ClearExtensionControlledDefaultSearchEngine() {
 219   Source old_source = GetDefaultSearchEngineSource();
 220   extension_default_search_.reset();
 221   if (old_source == FROM_EXTENSION)
 222     NotifyObserver();
 223 }
 224
 225 void DefaultSearchManager::ClearUserSelectedDefaultSearchEngine() {
 226   if (pref_service_) {
 227     pref_service_->ClearPref(kDefaultSearchProviderDataPrefName);
 228   } else {
 229     prefs_default_search_.reset();
 230     NotifyObserver();
 231   }
 232 }
 233
 234 void DefaultSearchManager::OnDefaultSearchPrefChanged() {
 235   Source source = GetDefaultSearchEngineSource();
 236   LoadDefaultSearchEngineFromPrefs();
 237
 238   // If we were/are FROM_USER or FROM_POLICY the effective DSE may have changed.
 239   if (source != FROM_USER && source != FROM_POLICY)
 240     source = GetDefaultSearchEngineSource();
 241   if (source == FROM_USER || source == FROM_POLICY)
 242     NotifyObserver();
 243 }
 244
 245 void DefaultSearchManager::OnOverridesPrefChanged() {
 246   LoadPrepopulatedDefaultSearch();
 247
 248   TemplateURLData* effective_data = GetDefaultSearchEngine(NULL);
 249   if (effective_data && effective_data->prepopulate_id) {
 250     // A user-selected, policy-selected or fallback pre-populated engine is
 251     // active and may have changed with this event.
 252     NotifyObserver();
 253   }
 254 }
 255
 256 void DefaultSearchManager::MergePrefsDataWithPrepopulated() {
 257   if (!prefs_default_search_ || !prefs_default_search_->prepopulate_id)
 258     return;
 259
 260   size_t default_search_index;
 261   ScopedVector<TemplateURLData> prepopulated_urls =
 262       TemplateURLPrepopulateData::GetPrepopulatedEngines(pref_service_,
 263                                                          &default_search_index);
 264
 265   for (size_t i = 0; i < prepopulated_urls.size(); ++i) {
 266     if (prepopulated_urls[i]->prepopulate_id ==
 267         prefs_default_search_->prepopulate_id) {
 268       if (!prefs_default_search_->safe_for_autoreplace) {
 269         prepopulated_urls[i]->safe_for_autoreplace = false;
 270         prepopulated_urls[i]->SetKeyword(prefs_default_search_->keyword());
 271         prepopulated_urls[i]->SetShortName(prefs_default_search_->short_name());
 272       }
 273       prepopulated_urls[i]->id = prefs_default_search_->id;
 274       prepopulated_urls[i]->sync_guid = prefs_default_search_->sync_guid;
 275       prepopulated_urls[i]->date_created = prefs_default_search_->date_created;
 276       prepopulated_urls[i]->last_modified =
 277           prefs_default_search_->last_modified;
 278       prefs_default_search_.reset(prepopulated_urls[i]);
 279       prepopulated_urls.weak_erase(prepopulated_urls.begin() + i);
 280       return;
 281     }
 282   }
 283 }
 284
 285 void DefaultSearchManager::LoadDefaultSearchEngineFromPrefs() {
 286   if (!pref_service_)
 287     return;
 288
 289   prefs_default_search_.reset();
 290   const PrefService::Preference* pref =
 291       pref_service_->FindPreference(kDefaultSearchProviderDataPrefName);
 292   DCHECK(pref);
 293   default_search_controlled_by_policy_ = pref->IsManaged();
 294
 295   const base::DictionaryValue* url_dict =
 296       pref_service_->GetDictionary(kDefaultSearchProviderDataPrefName);
 297   if (url_dict->empty())
 298     return;
 299
 300   if (default_search_controlled_by_policy_) {
 301     bool disabled_by_policy = false;
 302     if (url_dict->GetBoolean(kDisabledByPolicy, &disabled_by_policy) &&
 303         disabled_by_policy)
 304       return;
 305   }
 306
 307   std::string search_url;
 308   base::string16 keyword;
 309   url_dict->GetString(kURL, &search_url);
 310   url_dict->GetString(kKeyword, &keyword);
 311   if (search_url.empty() || keyword.empty())
 312     return;
 313
 314   prefs_default_search_.reset(new TemplateURLData);
 315   prefs_default_search_->SetKeyword(keyword);
 316   prefs_default_search_->SetURL(search_url);
 317
 318   std::string id;
 319   url_dict->GetString(kID, &id);
 320   base::StringToInt64(id, &prefs_default_search_->id);
 321   base::string16 short_name;
 322   url_dict->GetString(kShortName, &short_name);
 323   prefs_default_search_->SetShortName(short_name);
 324   url_dict->GetInteger(kPrepopulateID, &prefs_default_search_->prepopulate_id);
 325   url_dict->GetString(kSyncGUID, &prefs_default_search_->sync_guid);
 326
 327   url_dict->GetString(kSuggestionsURL, &prefs_default_search_->suggestions_url);
 328   url_dict->GetString(kInstantURL, &prefs_default_search_->instant_url);
 329   url_dict->GetString(kImageURL, &prefs_default_search_->image_url);
 330   url_dict->GetString(kNewTabURL, &prefs_default_search_->new_tab_url);
 331
 332   std::string favicon_url;
 333   std::string originating_url;
 334   url_dict->GetString(kFaviconURL, &favicon_url);
 335   url_dict->GetString(kOriginatingURL, &originating_url);
 336   prefs_default_search_->favicon_url = GURL(favicon_url);
 337   prefs_default_search_->originating_url = GURL(originating_url);
 338
 339   url_dict->GetString(kSearchURLPostParams,
 340                       &prefs_default_search_->search_url_post_params);
 341   url_dict->GetString(kSuggestionsURLPostParams,
 342                       &prefs_default_search_->suggestions_url_post_params);
 343   url_dict->GetString(kInstantURLPostParams,
 344                       &prefs_default_search_->instant_url_post_params);
 345   url_dict->GetString(kImageURLPostParams,
 346                       &prefs_default_search_->image_url_post_params);
 347
 348   url_dict->GetBoolean(kSafeForAutoReplace,
 349                        &prefs_default_search_->safe_for_autoreplace);
 350
 351   std::string date_created_str;
 352   std::string last_modified_str;
 353   url_dict->GetString(kDateCreated, &date_created_str);
 354   url_dict->GetString(kLastModified, &last_modified_str);
 355
 356   int64 date_created = 0;
 357   if (base::StringToInt64(date_created_str, &date_created)) {
 358     prefs_default_search_->date_created =
 359         base::Time::FromInternalValue(date_created);
 360   }
 361
 362   int64 last_modified = 0;
 363   if (base::StringToInt64(date_created_str, &last_modified)) {
 364     prefs_default_search_->last_modified =
 365         base::Time::FromInternalValue(last_modified);
 366   }
 367
 368   url_dict->GetInteger(kUsageCount, &prefs_default_search_->usage_count);
 369
 370   const base::ListValue* alternate_urls = NULL;
 371   if (url_dict->GetList(kAlternateURLs, &alternate_urls)) {
 372     for (base::ListValue::const_iterator it = alternate_urls->begin();
 373          it != alternate_urls->end();
 374          ++it) {
 375       std::string alternate_url;
 376       if ((*it)->GetAsString(&alternate_url))
 377         prefs_default_search_->alternate_urls.push_back(alternate_url);
 378     }
 379   }
 380
 381   const base::ListValue* encodings = NULL;
 382   if (url_dict->GetList(kInputEncodings, &encodings)) {
 383     for (base::ListValue::const_iterator it = encodings->begin();
 384          it != encodings->end();
 385          ++it) {
 386       std::string encoding;
 387       if ((*it)->GetAsString(&encoding))
 388         prefs_default_search_->input_encodings.push_back(encoding);
 389     }
 390   }
 391
 392   url_dict->GetString(kSearchTermsReplacementKey,
 393                       &prefs_default_search_->search_terms_replacement_key);
 394
 395   url_dict->GetBoolean(kCreatedByPolicy,
 396                        &prefs_default_search_->created_by_policy);
 397
 398   prefs_default_search_->show_in_default_list = true;
 399   MergePrefsDataWithPrepopulated();
 400 }
 401
 402 void DefaultSearchManager::LoadPrepopulatedDefaultSearch() {
 403   scoped_ptr<TemplateURLData> data =
 404       TemplateURLPrepopulateData::GetPrepopulatedDefaultSearch(pref_service_);
 405   fallback_default_search_ = data.Pass();
 406   MergePrefsDataWithPrepopulated();
 407 }
 408
 409 void DefaultSearchManager::NotifyObserver() {
 410   if (!change_observer_.is_null()) {
 411     Source source = FROM_FALLBACK;
 412     TemplateURLData* data = GetDefaultSearchEngine(&source);
 413     change_observer_.Run(data, source);
 414   }
 415 }