components/search_engines/default_search_manager.cc

   1 // Copyright 2014 The Chromium Authors
   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 <stddef.h>
   8 #include <stdint.h>
   9
  10 #include <memory>
  11 #include <utility>
  12
  13 #include "base/check.h"
  14 #include "base/compiler_specific.h"
  15 #include "base/functional/bind.h"
  16 #include "base/functional/callback_helpers.h"
  17 #include "base/i18n/case_conversion.h"
  18 #include "base/ranges/algorithm.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/prefs/pref_service.h"
  25 #include "components/prefs/pref_value_map.h"
  26 #include "components/search_engines/search_engines_pref_names.h"
  27 #include "components/search_engines/template_url_data.h"
  28 #include "components/search_engines/template_url_data_util.h"
  29 #include "components/search_engines/template_url_prepopulate_data.h"
  30
  31 namespace {
  32
  33 bool g_fallback_search_engines_disabled = false;
  34
  35 }  // namespace
  36
  37 // A dictionary to hold all data related to the Default Search Engine.
  38 // Eventually, this should replace all the data stored in the
  39 // default_search_provider.* prefs.
  40 const char DefaultSearchManager::kDefaultSearchProviderDataPrefName[] =
  41     "default_search_provider_data.template_url_data";
  42
  43 const char DefaultSearchManager::kID[] = "id";
  44 const char DefaultSearchManager::kShortName[] = "short_name";
  45 const char DefaultSearchManager::kKeyword[] = "keyword";
  46 const char DefaultSearchManager::kPrepopulateID[] = "prepopulate_id";
  47 const char DefaultSearchManager::kSyncGUID[] = "synced_guid";
  48
  49 const char DefaultSearchManager::kURL[] = "url";
  50 const char DefaultSearchManager::kSuggestionsURL[] = "suggestions_url";
  51 const char DefaultSearchManager::kImageURL[] = "image_url";
  52 const char DefaultSearchManager::kImageTranslateURL[] = "image_translate_url";
  53 const char DefaultSearchManager::kNewTabURL[] = "new_tab_url";
  54 const char DefaultSearchManager::kContextualSearchURL[] =
  55     "contextual_search_url";
  56 const char DefaultSearchManager::kFaviconURL[] = "favicon_url";
  57 const char DefaultSearchManager::kLogoURL[] = "logo_url";
  58 const char DefaultSearchManager::kDoodleURL[] = "doodle_url";
  59 const char DefaultSearchManager::kOriginatingURL[] = "originating_url";
  60
  61 const char DefaultSearchManager::kSearchURLPostParams[] =
  62     "search_url_post_params";
  63 const char DefaultSearchManager::kSuggestionsURLPostParams[] =
  64     "suggestions_url_post_params";
  65 const char DefaultSearchManager::kImageURLPostParams[] =
  66     "image_url_post_params";
  67 const char DefaultSearchManager::kSideSearchParam[] = "side_search_param";
  68 const char DefaultSearchManager::kSideImageSearchParam[] =
  69     "side_image_search_param";
  70 const char DefaultSearchManager::kImageSearchBrandingLabel[] =
  71     "image_search_branding_label";
  72 const char DefaultSearchManager::kSearchIntentParams[] = "search_intent_params";
  73 const char DefaultSearchManager::kImageTranslateSourceLanguageParamKey[] =
  74     "image_translate_source_language_param_key";
  75 const char DefaultSearchManager::kImageTranslateTargetLanguageParamKey[] =
  76     "image_translate_target_language_param_key";
  77
  78 const char DefaultSearchManager::kSafeForAutoReplace[] = "safe_for_autoreplace";
  79 const char DefaultSearchManager::kInputEncodings[] = "input_encodings";
  80
  81 const char DefaultSearchManager::kDateCreated[] = "date_created";
  82 const char DefaultSearchManager::kLastModified[] = "last_modified";
  83 const char DefaultSearchManager::kLastVisited[] = "last_visited";
  84
  85 const char DefaultSearchManager::kUsageCount[] = "usage_count";
  86 const char DefaultSearchManager::kAlternateURLs[] = "alternate_urls";
  87 const char DefaultSearchManager::kCreatedByPolicy[] = "created_by_policy";
  88 const char DefaultSearchManager::kDisabledByPolicy[] = "disabled_by_policy";
  89 const char DefaultSearchManager::kCreatedFromPlayAPI[] =
  90     "created_from_play_api";
  91 const char DefaultSearchManager::kPreconnectToSearchUrl[] =
  92     "preconnect_to_search_url";
  93 const char DefaultSearchManager::kPrefetchLikelyNavigations[] =
  94     "prefetch_likely_navigations";
  95 const char DefaultSearchManager::kIsActive[] = "is_active";
  96 const char DefaultSearchManager::kStarterPackId[] = "starter_pack_id";
  97 const char DefaultSearchManager::kEnforcedByPolicy[] = "enforced_by_policy";
  98
  99 DefaultSearchManager::DefaultSearchManager(
 100     PrefService* pref_service,
 101     const ObserverCallback& change_observer)
 102     : pref_service_(pref_service), change_observer_(change_observer) {
 103   if (pref_service_) {
 104     pref_change_registrar_.Init(pref_service_);
 105     pref_change_registrar_.Add(
 106         kDefaultSearchProviderDataPrefName,
 107         base::BindRepeating(&DefaultSearchManager::OnDefaultSearchPrefChanged,
 108                             base::Unretained(this)));
 109     pref_change_registrar_.Add(
 110         prefs::kSearchProviderOverrides,
 111         base::BindRepeating(&DefaultSearchManager::OnOverridesPrefChanged,
 112                             base::Unretained(this)));
 113   }
 114   LoadPrepopulatedDefaultSearch();
 115   LoadDefaultSearchEngineFromPrefs();
 116 }
 117
 118 DefaultSearchManager::~DefaultSearchManager() {
 119 }
 120
 121 // static
 122 void DefaultSearchManager::RegisterProfilePrefs(
 123     user_prefs::PrefRegistrySyncable* registry) {
 124   registry->RegisterDictionaryPref(kDefaultSearchProviderDataPrefName);
 125 }
 126
 127 // static
 128 void DefaultSearchManager::AddPrefValueToMap(base::Value::Dict value,
 129                                              PrefValueMap* pref_value_map) {
 130   pref_value_map->SetValue(kDefaultSearchProviderDataPrefName,
 131                            base::Value(std::move(value)));
 132 }
 133
 134 // static
 135 void DefaultSearchManager::SetFallbackSearchEnginesDisabledForTesting(
 136     bool disabled) {
 137   g_fallback_search_engines_disabled = disabled;
 138 }
 139
 140 const TemplateURLData* DefaultSearchManager::GetDefaultSearchEngine(
 141     Source* source) const {
 142   if (default_search_mandatory_by_policy_) {
 143     if (source)
 144       *source = FROM_POLICY;
 145     return prefs_default_search_.get();
 146   }
 147   if (default_search_recommended_by_policy_) {
 148     if (source)
 149       *source = FROM_POLICY_RECOMMENDED;
 150     return prefs_default_search_.get();
 151   }
 152   if (extension_default_search_) {
 153     if (source)
 154       *source = FROM_EXTENSION;
 155     return extension_default_search_.get();
 156   }
 157   if (prefs_default_search_) {
 158     if (source)
 159       *source = FROM_USER;
 160     return prefs_default_search_.get();
 161   }
 162   if (source)
 163     *source = FROM_FALLBACK;
 164   return GetFallbackSearchEngine();
 165 }
 166
 167 std::unique_ptr<TemplateURLData>
 168 DefaultSearchManager::GetDefaultSearchEngineIgnoringExtensions() const {
 169   if (prefs_default_search_)
 170     return std::make_unique<TemplateURLData>(*prefs_default_search_);
 171
 172   if (default_search_mandatory_by_policy_ ||
 173       default_search_recommended_by_policy_) {
 174     // If a policy specified a specific engine, it would be returned above
 175     // as |prefs_default_search_|. The only other scenario is that policy has
 176     // disabled default search, in which case we return null.
 177     return nullptr;
 178   }
 179
 180   // |prefs_default_search_| may not be populated even if there is a user
 181   // preference; check prefs directly as the source of truth.
 182   const base::Value* user_value =
 183       pref_service_->GetUserPrefValue(kDefaultSearchProviderDataPrefName);
 184   if (user_value && user_value->is_dict()) {
 185     auto turl_data = TemplateURLDataFromDictionary(user_value->GetDict());
 186     if (turl_data)
 187       return turl_data;
 188   }
 189
 190   const TemplateURLData* fallback = GetFallbackSearchEngine();
 191   if (fallback)
 192     return std::make_unique<TemplateURLData>(*fallback);
 193
 194   return nullptr;
 195 }
 196
 197 DefaultSearchManager::Source
 198 DefaultSearchManager::GetDefaultSearchEngineSource() const {
 199   Source source;
 200   GetDefaultSearchEngine(&source);
 201   return source;
 202 }
 203
 204 const TemplateURLData* DefaultSearchManager::GetFallbackSearchEngine() const {
 205   return g_fallback_search_engines_disabled ? nullptr
 206                                             : fallback_default_search_.get();
 207 }
 208
 209 void DefaultSearchManager::SetUserSelectedDefaultSearchEngine(
 210     const TemplateURLData& data) {
 211   if (!pref_service_) {
 212     prefs_default_search_ = std::make_unique<TemplateURLData>(data);
 213     MergePrefsDataWithPrepopulated();
 214     NotifyObserver();
 215     return;
 216   }
 217
 218   pref_service_->SetDict(kDefaultSearchProviderDataPrefName,
 219                          TemplateURLDataToDictionary(data));
 220 }
 221
 222 void DefaultSearchManager::ClearUserSelectedDefaultSearchEngine() {
 223   if (pref_service_) {
 224     pref_service_->ClearPref(kDefaultSearchProviderDataPrefName);
 225   } else {
 226     prefs_default_search_.reset();
 227     NotifyObserver();
 228   }
 229 }
 230
 231 void DefaultSearchManager::OnDefaultSearchPrefChanged() {
 232   bool source_was_fallback = GetDefaultSearchEngineSource() == FROM_FALLBACK;
 233
 234   LoadDefaultSearchEngineFromPrefs();
 235
 236   // The effective DSE may have changed unless we were using the fallback source
 237   // both before and after the above load.
 238   if (!source_was_fallback || (GetDefaultSearchEngineSource() != FROM_FALLBACK))
 239     NotifyObserver();
 240 }
 241
 242 void DefaultSearchManager::OnOverridesPrefChanged() {
 243   LoadPrepopulatedDefaultSearch();
 244
 245   const TemplateURLData* effective_data = GetDefaultSearchEngine(nullptr);
 246   if (effective_data && effective_data->prepopulate_id) {
 247     // A user-selected, policy-selected or fallback pre-populated engine is
 248     // active and may have changed with this event.
 249     NotifyObserver();
 250   }
 251 }
 252
 253 void DefaultSearchManager::MergePrefsDataWithPrepopulated() {
 254   if (!prefs_default_search_ || !prefs_default_search_->prepopulate_id)
 255     return;
 256
 257   // TODO(crbug.com/1049784): Parameters for search engine created from play api
 258   // should be preserved even if corresponding prepopulated search engine
 259   // exists. This logic will be revisited as part of implementation of
 260   // crbug.com/1049784, which will enable updating play api search engine
 261   // parameters with prepopulated data.
 262   if (prefs_default_search_->created_from_play_api)
 263     return;
 264
 265   std::vector<std::unique_ptr<TemplateURLData>> prepopulated_urls =
 266       TemplateURLPrepopulateData::GetPrepopulatedEngines(pref_service_,
 267                                                          nullptr);
 268
 269   auto default_engine = base::ranges::find(
 270       prepopulated_urls, prefs_default_search_->prepopulate_id,
 271       &TemplateURLData::prepopulate_id);
 272
 273   if (default_engine == prepopulated_urls.end())
 274     return;
 275
 276   auto& engine = *default_engine;
 277
 278   if (!prefs_default_search_->safe_for_autoreplace) {
 279     engine->safe_for_autoreplace = false;
 280     engine->SetKeyword(prefs_default_search_->keyword());
 281     engine->SetShortName(prefs_default_search_->short_name());
 282   }
 283
 284   engine->id = prefs_default_search_->id;
 285   engine->sync_guid = prefs_default_search_->sync_guid;
 286   engine->date_created = prefs_default_search_->date_created;
 287   engine->last_modified = prefs_default_search_->last_modified;
 288   engine->last_visited = prefs_default_search_->last_visited;
 289   engine->favicon_url = prefs_default_search_->favicon_url;
 290
 291   prefs_default_search_ = std::move(engine);
 292 }
 293
 294 void DefaultSearchManager::LoadDefaultSearchEngineFromPrefs() {
 295   if (!pref_service_)
 296     return;
 297
 298   prefs_default_search_.reset();
 299   extension_default_search_.reset();
 300   const PrefService::Preference* pref =
 301       pref_service_->FindPreference(kDefaultSearchProviderDataPrefName);
 302   DCHECK(pref);
 303   default_search_mandatory_by_policy_ = pref->IsManaged();
 304   default_search_recommended_by_policy_ = pref->IsRecommended();
 305
 306   const base::Value::Dict& url_dict =
 307       pref_service_->GetDict(kDefaultSearchProviderDataPrefName);
 308   if (url_dict.empty())
 309     return;
 310
 311   if (default_search_mandatory_by_policy_ ||
 312       default_search_recommended_by_policy_) {
 313     if (url_dict.FindBool(kDisabledByPolicy).value_or(false))
 314       return;
 315   }
 316
 317   auto turl_data = TemplateURLDataFromDictionary(url_dict);
 318   if (!turl_data)
 319     return;
 320
 321   // Check if default search preference is overriden by extension.
 322   if (pref->IsExtensionControlled()) {
 323     extension_default_search_ = std::move(turl_data);
 324   } else {
 325     prefs_default_search_ = std::move(turl_data);
 326     MergePrefsDataWithPrepopulated();
 327   }
 328 }
 329
 330 void DefaultSearchManager::LoadPrepopulatedDefaultSearch() {
 331   std::unique_ptr<TemplateURLData> data =
 332       TemplateURLPrepopulateData::GetPrepopulatedDefaultSearch(pref_service_);
 333   fallback_default_search_ = std::move(data);
 334   MergePrefsDataWithPrepopulated();
 335 }
 336
 337 void DefaultSearchManager::NotifyObserver() {
 338   if (!change_observer_.is_null()) {
 339     Source source = FROM_FALLBACK;
 340     const TemplateURLData* data = GetDefaultSearchEngine(&source);
 341     change_observer_.Run(data, source);
 342   }
 343 }