| OLD | NEW |
|---|
| (Empty) |
| 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 "chrome/browser/search_engines/util.h" | |
| 6 | |
| 7 #include <map> | |
| 8 #include <set> | |
| 9 #include <string> | |
| 10 #include <vector> | |
| 11 | |
| 12 #include "base/logging.h" | |
| 13 #include "base/memory/scoped_vector.h" | |
| 14 #include "base/prefs/pref_service.h" | |
| 15 #include "base/time/time.h" | |
| 16 #include "chrome/browser/search_engines/template_url_service.h" | |
| 17 #include "components/search_engines/template_url.h" | |
| 18 #include "components/search_engines/template_url_prepopulate_data.h" | |
| 19 | |
| 20 base::string16 GetDefaultSearchEngineName(TemplateURLService* service) { | |
| 21 DCHECK(service); | |
| 22 const TemplateURL* const default_provider = | |
| 23 service->GetDefaultSearchProvider(); | |
| 24 if (!default_provider) { | |
| 25 // TODO(cpu): bug 1187517. It is possible to have no default provider. | |
| 26 // returning an empty string is a stopgap measure for the crash | |
| 27 // http://code.google.com/p/chromium/issues/detail?id=2573 | |
| 28 return base::string16(); | |
| 29 } | |
| 30 return default_provider->short_name(); | |
| 31 } | |
| 32 | |
| 33 GURL GetDefaultSearchURLForSearchTerms(TemplateURLService* service, | |
| 34 const base::string16& terms) { | |
| 35 DCHECK(service); | |
| 36 const TemplateURL* default_provider = service->GetDefaultSearchProvider(); | |
| 37 if (!default_provider) | |
| 38 return GURL(); | |
| 39 const TemplateURLRef& search_url = default_provider->url_ref(); | |
| 40 DCHECK(search_url.SupportsReplacement(service->search_terms_data())); | |
| 41 TemplateURLRef::SearchTermsArgs search_terms_args(terms); | |
| 42 search_terms_args.append_extra_query_params = true; | |
| 43 return GURL(search_url.ReplaceSearchTerms(search_terms_args, | |
| 44 service->search_terms_data())); | |
| 45 } | |
| 46 | |
| 47 void RemoveDuplicatePrepopulateIDs( | |
| 48 KeywordWebDataService* service, | |
| 49 const ScopedVector<TemplateURLData>& prepopulated_urls, | |
| 50 TemplateURL* default_search_provider, | |
| 51 TemplateURLService::TemplateURLVector* template_urls, | |
| 52 const SearchTermsData& search_terms_data, | |
| 53 std::set<std::string>* removed_keyword_guids) { | |
| 54 DCHECK(template_urls); | |
| 55 | |
| 56 // For convenience construct an ID->TemplateURL* map from |prepopulated_urls|. | |
| 57 typedef std::map<int, TemplateURLData*> PrepopulatedURLMap; | |
| 58 PrepopulatedURLMap prepopulated_url_map; | |
| 59 for (std::vector<TemplateURLData*>::const_iterator i( | |
| 60 prepopulated_urls.begin()); | |
| 61 i != prepopulated_urls.end(); | |
| 62 ++i) | |
| 63 prepopulated_url_map[(*i)->prepopulate_id] = *i; | |
| 64 | |
| 65 // Separate |template_urls| into prepopulated and non-prepopulated groups. | |
| 66 typedef std::multimap<int, TemplateURL*> UncheckedURLMap; | |
| 67 UncheckedURLMap unchecked_urls; | |
| 68 TemplateURLService::TemplateURLVector checked_urls; | |
| 69 for (TemplateURLService::TemplateURLVector::iterator i( | |
| 70 template_urls->begin()); i != template_urls->end(); ++i) { | |
| 71 TemplateURL* turl = *i; | |
| 72 int prepopulate_id = turl->prepopulate_id(); | |
| 73 if (prepopulate_id) | |
| 74 unchecked_urls.insert(std::make_pair(prepopulate_id, turl)); | |
| 75 else | |
| 76 checked_urls.push_back(turl); | |
| 77 } | |
| 78 | |
| 79 // For each group of prepopulated URLs with one ID, find the best URL to use | |
| 80 // and add it to the (initially all non-prepopulated) URLs we've already OKed. | |
| 81 // Delete the others from the service and from memory. | |
| 82 while (!unchecked_urls.empty()) { | |
| 83 // Find the best URL. | |
| 84 int prepopulate_id = unchecked_urls.begin()->first; | |
| 85 PrepopulatedURLMap::const_iterator prepopulated_url = | |
| 86 prepopulated_url_map.find(prepopulate_id); | |
| 87 UncheckedURLMap::iterator end = unchecked_urls.upper_bound(prepopulate_id); | |
| 88 UncheckedURLMap::iterator best = unchecked_urls.begin(); | |
| 89 bool matched_keyword = false; | |
| 90 for (UncheckedURLMap::iterator i = unchecked_urls.begin(); i != end; ++i) { | |
| 91 // If the user-selected DSE is a prepopulated engine its properties will | |
| 92 // either come from the prepopulation origin or from the user preferences | |
| 93 // file (see DefaultSearchManager). Those properties will end up | |
| 94 // overwriting whatever we load now anyway. If we are eliminating | |
| 95 // duplicates, then, we err on the side of keeping the thing that looks | |
| 96 // more like the value we will end up with in the end. | |
| 97 if (default_search_provider && | |
| 98 (default_search_provider->prepopulate_id() == | |
| 99 i->second->prepopulate_id()) && | |
| 100 default_search_provider->HasSameKeywordAs(i->second->data(), | |
| 101 search_terms_data)) { | |
| 102 best = i; | |
| 103 break; | |
| 104 } | |
| 105 | |
| 106 // Otherwise, a URL is best if it matches the prepopulated data's keyword; | |
| 107 // if none match, just fall back to using the one with the lowest ID. | |
| 108 if (matched_keyword) | |
| 109 continue; | |
| 110 if ((prepopulated_url != prepopulated_url_map.end()) && | |
| 111 i->second->HasSameKeywordAs(*prepopulated_url->second, | |
| 112 search_terms_data)) { | |
| 113 best = i; | |
| 114 matched_keyword = true; | |
| 115 } else if (i->second->id() < best->second->id()) { | |
| 116 best = i; | |
| 117 } | |
| 118 } | |
| 119 | |
| 120 // Add the best URL to the checked group and delete the rest. | |
| 121 checked_urls.push_back(best->second); | |
| 122 for (UncheckedURLMap::iterator i = unchecked_urls.begin(); i != end; ++i) { | |
| 123 if (i == best) | |
| 124 continue; | |
| 125 if (service) { | |
| 126 service->RemoveKeyword(i->second->id()); | |
| 127 if (removed_keyword_guids) | |
| 128 removed_keyword_guids->insert(i->second->sync_guid()); | |
| 129 } | |
| 130 delete i->second; | |
| 131 } | |
| 132 | |
| 133 // Done with this group. | |
| 134 unchecked_urls.erase(unchecked_urls.begin(), end); | |
| 135 } | |
| 136 | |
| 137 // Return the checked URLs. | |
| 138 template_urls->swap(checked_urls); | |
| 139 } | |
| 140 | |
| 141 // Returns the TemplateURL with id specified from the list of TemplateURLs. | |
| 142 // If not found, returns NULL. | |
| 143 TemplateURL* GetTemplateURLByID( | |
| 144 const TemplateURLService::TemplateURLVector& template_urls, | |
| 145 int64 id) { | |
| 146 for (TemplateURLService::TemplateURLVector::const_iterator i( | |
| 147 template_urls.begin()); i != template_urls.end(); ++i) { | |
| 148 if ((*i)->id() == id) { | |
| 149 return *i; | |
| 150 } | |
| 151 } | |
| 152 return NULL; | |
| 153 } | |
| 154 | |
| 155 TemplateURL* FindURLByPrepopulateID( | |
| 156 const TemplateURLService::TemplateURLVector& template_urls, | |
| 157 int prepopulate_id) { | |
| 158 for (std::vector<TemplateURL*>::const_iterator i = template_urls.begin(); | |
| 159 i < template_urls.end(); ++i) { | |
| 160 if ((*i)->prepopulate_id() == prepopulate_id) | |
| 161 return *i; | |
| 162 } | |
| 163 return NULL; | |
| 164 } | |
| 165 | |
| 166 void MergeIntoPrepopulatedEngineData(const TemplateURL* original_turl, | |
| 167 TemplateURLData* prepopulated_url) { | |
| 168 DCHECK_EQ(original_turl->prepopulate_id(), prepopulated_url->prepopulate_id); | |
| 169 if (!original_turl->safe_for_autoreplace()) { | |
| 170 prepopulated_url->safe_for_autoreplace = false; | |
| 171 prepopulated_url->SetKeyword(original_turl->keyword()); | |
| 172 prepopulated_url->short_name = original_turl->short_name(); | |
| 173 } | |
| 174 prepopulated_url->id = original_turl->id(); | |
| 175 prepopulated_url->sync_guid = original_turl->sync_guid(); | |
| 176 prepopulated_url->date_created = original_turl->date_created(); | |
| 177 prepopulated_url->last_modified = original_turl->last_modified(); | |
| 178 } | |
| 179 | |
| 180 ActionsFromPrepopulateData::ActionsFromPrepopulateData() {} | |
| 181 | |
| 182 ActionsFromPrepopulateData::~ActionsFromPrepopulateData() {} | |
| 183 | |
| 184 // This is invoked when the version of the prepopulate data changes. | |
| 185 // If |removed_keyword_guids| is not NULL, the Sync GUID of each item removed | |
| 186 // from the DB will be added to it. Note that this function will take | |
| 187 // ownership of |prepopulated_urls| and will clear the vector. | |
| 188 void MergeEnginesFromPrepopulateData( | |
| 189 KeywordWebDataService* service, | |
| 190 ScopedVector<TemplateURLData>* prepopulated_urls, | |
| 191 size_t default_search_index, | |
| 192 TemplateURLService::TemplateURLVector* template_urls, | |
| 193 TemplateURL* default_search_provider, | |
| 194 std::set<std::string>* removed_keyword_guids) { | |
| 195 DCHECK(prepopulated_urls); | |
| 196 DCHECK(template_urls); | |
| 197 | |
| 198 ActionsFromPrepopulateData actions(CreateActionsFromCurrentPrepopulateData( | |
| 199 prepopulated_urls, *template_urls, default_search_provider)); | |
| 200 | |
| 201 // Remove items. | |
| 202 for (std::vector<TemplateURL*>::iterator i = actions.removed_engines.begin(); | |
| 203 i < actions.removed_engines.end(); ++i) { | |
| 204 scoped_ptr<TemplateURL> template_url(*i); | |
| 205 TemplateURLService::TemplateURLVector::iterator j = | |
| 206 std::find(template_urls->begin(), template_urls->end(), template_url); | |
| 207 DCHECK(j != template_urls->end()); | |
| 208 DCHECK(!default_search_provider || | |
| 209 (*j)->prepopulate_id() != default_search_provider->prepopulate_id()); | |
| 210 template_urls->erase(j); | |
| 211 if (service) { | |
| 212 service->RemoveKeyword(template_url->id()); | |
| 213 if (removed_keyword_guids) | |
| 214 removed_keyword_guids->insert(template_url->sync_guid()); | |
| 215 } | |
| 216 } | |
| 217 | |
| 218 // Edit items. | |
| 219 for (EditedEngines::iterator i(actions.edited_engines.begin()); | |
| 220 i < actions.edited_engines.end(); ++i) { | |
| 221 TemplateURLData& data = i->second; | |
| 222 scoped_ptr<TemplateURL> existing_url(i->first); | |
| 223 if (service) | |
| 224 service->UpdateKeyword(data); | |
| 225 | |
| 226 // Replace the entry in |template_urls| with the updated one. | |
| 227 TemplateURLService::TemplateURLVector::iterator j = std::find( | |
| 228 template_urls->begin(), template_urls->end(), existing_url.get()); | |
| 229 *j = new TemplateURL(data); | |
| 230 } | |
| 231 | |
| 232 // Add items. | |
| 233 for (std::vector<TemplateURLData>::const_iterator it = | |
| 234 actions.added_engines.begin(); | |
| 235 it != actions.added_engines.end(); | |
| 236 ++it) { | |
| 237 template_urls->push_back(new TemplateURL(*it)); | |
| 238 } | |
| 239 } | |
| 240 | |
| 241 ActionsFromPrepopulateData CreateActionsFromCurrentPrepopulateData( | |
| 242 ScopedVector<TemplateURLData>* prepopulated_urls, | |
| 243 const TemplateURLService::TemplateURLVector& existing_urls, | |
| 244 const TemplateURL* default_search_provider) { | |
| 245 // Create a map to hold all provided |template_urls| that originally came from | |
| 246 // prepopulate data (i.e. have a non-zero prepopulate_id()). | |
| 247 typedef std::map<int, TemplateURL*> IDMap; | |
| 248 IDMap id_to_turl; | |
| 249 for (TemplateURLService::TemplateURLVector::const_iterator i( | |
| 250 existing_urls.begin()); i != existing_urls.end(); ++i) { | |
| 251 int prepopulate_id = (*i)->prepopulate_id(); | |
| 252 if (prepopulate_id > 0) | |
| 253 id_to_turl[prepopulate_id] = *i; | |
| 254 } | |
| 255 | |
| 256 // For each current prepopulated URL, check whether |template_urls| contained | |
| 257 // a matching prepopulated URL. If so, update the passed-in URL to match the | |
| 258 // current data. (If the passed-in URL was user-edited, we persist the user's | |
| 259 // name and keyword.) If not, add the prepopulated URL. | |
| 260 ActionsFromPrepopulateData actions; | |
| 261 for (size_t i = 0; i < prepopulated_urls->size(); ++i) { | |
| 262 // We take ownership of |prepopulated_urls[i]|. | |
| 263 scoped_ptr<TemplateURLData> prepopulated_url((*prepopulated_urls)[i]); | |
| 264 const int prepopulated_id = prepopulated_url->prepopulate_id; | |
| 265 DCHECK_NE(0, prepopulated_id); | |
| 266 | |
| 267 IDMap::iterator existing_url_iter(id_to_turl.find(prepopulated_id)); | |
| 268 if (existing_url_iter != id_to_turl.end()) { | |
| 269 // Update the data store with the new prepopulated data. Preserve user | |
| 270 // edits to the name and keyword. | |
| 271 TemplateURL* existing_url(existing_url_iter->second); | |
| 272 id_to_turl.erase(existing_url_iter); | |
| 273 MergeIntoPrepopulatedEngineData(existing_url, prepopulated_url.get()); | |
| 274 // Update last_modified to ensure that if this entry is later merged with | |
| 275 // entries from Sync, the conflict resolution logic knows that this was | |
| 276 // updated and propagates the new values to the server. | |
| 277 prepopulated_url->last_modified = base::Time::Now(); | |
| 278 actions.edited_engines.push_back( | |
| 279 std::make_pair(existing_url, *prepopulated_url)); | |
| 280 } else { | |
| 281 actions.added_engines.push_back(*prepopulated_url); | |
| 282 } | |
| 283 } | |
| 284 // The above loop takes ownership of all the contents of prepopulated_urls. | |
| 285 // Clear the pointers. | |
| 286 prepopulated_urls->weak_erase(prepopulated_urls->begin(), | |
| 287 prepopulated_urls->end()); | |
| 288 | |
| 289 // The block above removed all the URLs from the |id_to_turl| map that were | |
| 290 // found in the prepopulate data. Any remaining URLs that haven't been | |
| 291 // user-edited or made default can be removed from the data store. | |
| 292 // We assume that this entry is equivalent to the DSE if its prepopulate ID | |
| 293 // and keyword both match. If the prepopulate ID _does_ match all properties | |
| 294 // will be replaced with those from |default_search_provider| anyway. | |
| 295 for (IDMap::iterator i(id_to_turl.begin()); i != id_to_turl.end(); ++i) { | |
| 296 TemplateURL* template_url = i->second; | |
| 297 if ((template_url->safe_for_autoreplace()) && | |
| 298 (!default_search_provider || | |
| 299 (template_url->prepopulate_id() != | |
| 300 default_search_provider->prepopulate_id()) || | |
| 301 (template_url->keyword() != default_search_provider->keyword()))) | |
| 302 actions.removed_engines.push_back(template_url); | |
| 303 } | |
| 304 | |
| 305 return actions; | |
| 306 } | |
| 307 | |
| 308 void GetSearchProvidersUsingKeywordResult( | |
| 309 const WDTypedResult& result, | |
| 310 KeywordWebDataService* service, | |
| 311 PrefService* prefs, | |
| 312 TemplateURLService::TemplateURLVector* template_urls, | |
| 313 TemplateURL* default_search_provider, | |
| 314 const SearchTermsData& search_terms_data, | |
| 315 int* new_resource_keyword_version, | |
| 316 std::set<std::string>* removed_keyword_guids) { | |
| 317 DCHECK(template_urls); | |
| 318 DCHECK(template_urls->empty()); | |
| 319 DCHECK_EQ(KEYWORDS_RESULT, result.GetType()); | |
| 320 DCHECK(new_resource_keyword_version); | |
| 321 | |
| 322 WDKeywordsResult keyword_result = reinterpret_cast< | |
| 323 const WDResult<WDKeywordsResult>*>(&result)->GetValue(); | |
| 324 | |
| 325 for (KeywordTable::Keywords::iterator i(keyword_result.keywords.begin()); | |
| 326 i != keyword_result.keywords.end(); ++i) { | |
| 327 // Fix any duplicate encodings in the local database. Note that we don't | |
| 328 // adjust the last_modified time of this keyword; this way, we won't later | |
| 329 // overwrite any changes on the sync server that happened to this keyword | |
| 330 // since the last time we synced. Instead, we also run a de-duping pass on | |
| 331 // the server-provided data in | |
| 332 // TemplateURLService::CreateTemplateURLFromTemplateURLAndSyncData() and | |
| 333 // update the server with the merged, de-duped results at that time. We | |
| 334 // still fix here, though, to correct problems in clients that have disabled | |
| 335 // search engine sync, since in that case that code will never be reached. | |
| 336 if (DeDupeEncodings(&i->input_encodings) && service) | |
| 337 service->UpdateKeyword(*i); | |
| 338 template_urls->push_back(new TemplateURL(*i)); | |
| 339 } | |
| 340 | |
| 341 *new_resource_keyword_version = keyword_result.builtin_keyword_version; | |
| 342 GetSearchProvidersUsingLoadedEngines(service, prefs, template_urls, | |
| 343 default_search_provider, | |
| 344 search_terms_data, | |
| 345 new_resource_keyword_version, | |
| 346 removed_keyword_guids); | |
| 347 } | |
| 348 | |
| 349 void GetSearchProvidersUsingLoadedEngines( | |
| 350 KeywordWebDataService* service, | |
| 351 PrefService* prefs, | |
| 352 TemplateURLService::TemplateURLVector* template_urls, | |
| 353 TemplateURL* default_search_provider, | |
| 354 const SearchTermsData& search_terms_data, | |
| 355 int* resource_keyword_version, | |
| 356 std::set<std::string>* removed_keyword_guids) { | |
| 357 DCHECK(template_urls); | |
| 358 DCHECK(resource_keyword_version); | |
| 359 size_t default_search_index; | |
| 360 ScopedVector<TemplateURLData> prepopulated_urls = | |
| 361 TemplateURLPrepopulateData::GetPrepopulatedEngines(prefs, | |
| 362 &default_search_index); | |
| 363 RemoveDuplicatePrepopulateIDs(service, prepopulated_urls, | |
| 364 default_search_provider, template_urls, | |
| 365 search_terms_data, removed_keyword_guids); | |
| 366 | |
| 367 const int prepopulate_resource_keyword_version = | |
| 368 TemplateURLPrepopulateData::GetDataVersion(prefs); | |
| 369 if (*resource_keyword_version < prepopulate_resource_keyword_version) { | |
| 370 MergeEnginesFromPrepopulateData( | |
| 371 service, &prepopulated_urls, default_search_index, template_urls, | |
| 372 default_search_provider, removed_keyword_guids); | |
| 373 *resource_keyword_version = prepopulate_resource_keyword_version; | |
| 374 } else { | |
| 375 *resource_keyword_version = 0; | |
| 376 } | |
| 377 } | |
| 378 | |
| 379 bool DeDupeEncodings(std::vector<std::string>* encodings) { | |
| 380 std::vector<std::string> deduped_encodings; | |
| 381 std::set<std::string> encoding_set; | |
| 382 for (std::vector<std::string>::const_iterator i(encodings->begin()); | |
| 383 i != encodings->end(); ++i) { | |
| 384 if (encoding_set.insert(*i).second) | |
| 385 deduped_encodings.push_back(*i); | |
| 386 } | |
| 387 encodings->swap(deduped_encodings); | |
| 388 return encodings->size() != deduped_encodings.size(); | |
| 389 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 367023002:
Componentize TemplateURLService (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src