1// Copyright (c) 2012 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/autocomplete/shortcuts_backend.h" 6 7#include <map> 8#include <string> 9#include <vector> 10 11#include "base/bind.h" 12#include "base/bind_helpers.h" 13#include "base/guid.h" 14#include "base/i18n/case_conversion.h" 15#include "base/strings/string_util.h" 16#include "chrome/browser/chrome_notification_types.h" 17#include "chrome/browser/history/history_notifications.h" 18#include "chrome/browser/history/history_service.h" 19#include "chrome/browser/history/shortcuts_database.h" 20#include "chrome/browser/omnibox/omnibox_log.h" 21#include "chrome/browser/profiles/profile.h" 22#include "chrome/browser/search_engines/template_url_service_factory.h" 23#include "chrome/browser/search_engines/ui_thread_search_terms_data.h" 24#include "chrome/common/chrome_constants.h" 25#include "components/omnibox/autocomplete_input.h" 26#include "components/omnibox/autocomplete_match.h" 27#include "components/omnibox/autocomplete_match_type.h" 28#include "components/omnibox/autocomplete_result.h" 29#include "components/omnibox/base_search_provider.h" 30#include "content/public/browser/browser_thread.h" 31#include "content/public/browser/notification_details.h" 32#include "content/public/browser/notification_source.h" 33#include "extensions/browser/notification_types.h" 34#include "extensions/common/extension.h" 35 36using content::BrowserThread; 37 38namespace { 39 40// Takes Match classification vector and removes all matched positions, 41// compacting repetitions if necessary. 42std::string StripMatchMarkers(const ACMatchClassifications& matches) { 43 ACMatchClassifications unmatched; 44 for (ACMatchClassifications::const_iterator i(matches.begin()); 45 i != matches.end(); ++i) { 46 AutocompleteMatch::AddLastClassificationIfNecessary( 47 &unmatched, i->offset, i->style & ~ACMatchClassification::MATCH); 48 } 49 return AutocompleteMatch::ClassificationsToString(unmatched); 50} 51 52// Normally shortcuts have the same match type as the original match they were 53// created from, but for certain match types, we should modify the shortcut's 54// type slightly to reflect that the origin of the shortcut is historical. 55AutocompleteMatch::Type GetTypeForShortcut(AutocompleteMatch::Type type) { 56 switch (type) { 57 case AutocompleteMatchType::URL_WHAT_YOU_TYPED: 58 case AutocompleteMatchType::NAVSUGGEST: 59 case AutocompleteMatchType::NAVSUGGEST_PERSONALIZED: 60 return AutocompleteMatchType::HISTORY_URL; 61 62 case AutocompleteMatchType::SEARCH_OTHER_ENGINE: 63 return type; 64 65 default: 66 return AutocompleteMatch::IsSearchType(type) ? 67 AutocompleteMatchType::SEARCH_HISTORY : type; 68 } 69} 70 71} // namespace 72 73 74// ShortcutsBackend ----------------------------------------------------------- 75 76ShortcutsBackend::ShortcutsBackend(Profile* profile, bool suppress_db) 77 : profile_(profile), 78 current_state_(NOT_INITIALIZED), 79 no_db_access_(suppress_db) { 80 if (!suppress_db) { 81 db_ = new history::ShortcutsDatabase( 82 profile->GetPath().Append(chrome::kShortcutsDatabaseName)); 83 } 84 // |profile| can be NULL in tests. 85 if (profile) { 86 notification_registrar_.Add( 87 this, 88 extensions::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED, 89 content::Source<Profile>(profile)); 90 notification_registrar_.Add( 91 this, chrome::NOTIFICATION_HISTORY_URLS_DELETED, 92 content::Source<Profile>(profile)); 93 } 94} 95 96bool ShortcutsBackend::Init() { 97 if (current_state_ != NOT_INITIALIZED) 98 return false; 99 100 if (no_db_access_) { 101 current_state_ = INITIALIZED; 102 return true; 103 } 104 105 current_state_ = INITIALIZING; 106 return BrowserThread::PostTask(BrowserThread::DB, FROM_HERE, 107 base::Bind(&ShortcutsBackend::InitInternal, this)); 108} 109 110bool ShortcutsBackend::DeleteShortcutsWithURL(const GURL& shortcut_url) { 111 return initialized() && DeleteShortcutsWithURL(shortcut_url, true); 112} 113 114void ShortcutsBackend::AddObserver(ShortcutsBackendObserver* obs) { 115 observer_list_.AddObserver(obs); 116} 117 118void ShortcutsBackend::RemoveObserver(ShortcutsBackendObserver* obs) { 119 observer_list_.RemoveObserver(obs); 120} 121 122void ShortcutsBackend::AddOrUpdateShortcut(const base::string16& text, 123 const AutocompleteMatch& match) { 124 const base::string16 text_lowercase(base::i18n::ToLower(text)); 125 const base::Time now(base::Time::Now()); 126 for (ShortcutMap::const_iterator it( 127 shortcuts_map_.lower_bound(text_lowercase)); 128 it != shortcuts_map_.end() && 129 StartsWith(it->first, text_lowercase, true); ++it) { 130 if (match.destination_url == it->second.match_core.destination_url) { 131 UpdateShortcut(history::ShortcutsDatabase::Shortcut( 132 it->second.id, text, MatchToMatchCore(match, profile_), now, 133 it->second.number_of_hits + 1)); 134 return; 135 } 136 } 137 AddShortcut(history::ShortcutsDatabase::Shortcut( 138 base::GenerateGUID(), text, MatchToMatchCore(match, profile_), now, 1)); 139} 140 141ShortcutsBackend::~ShortcutsBackend() { 142} 143 144// static 145history::ShortcutsDatabase::Shortcut::MatchCore 146 ShortcutsBackend::MatchToMatchCore(const AutocompleteMatch& match, 147 Profile* profile) { 148 const AutocompleteMatch::Type match_type = GetTypeForShortcut(match.type); 149 TemplateURLService* service = 150 TemplateURLServiceFactory::GetForProfile(profile); 151 const AutocompleteMatch& normalized_match = 152 AutocompleteMatch::IsSpecializedSearchType(match.type) ? 153 BaseSearchProvider::CreateSearchSuggestion( 154 match.search_terms_args->search_terms, match_type, 155 (match.transition == ui::PAGE_TRANSITION_KEYWORD), 156 match.GetTemplateURL(service, false), 157 UIThreadSearchTermsData(profile)) : 158 match; 159 return history::ShortcutsDatabase::Shortcut::MatchCore( 160 normalized_match.fill_into_edit, normalized_match.destination_url, 161 normalized_match.contents, 162 StripMatchMarkers(normalized_match.contents_class), 163 normalized_match.description, 164 StripMatchMarkers(normalized_match.description_class), 165 normalized_match.transition, match_type, normalized_match.keyword); 166} 167 168void ShortcutsBackend::ShutdownOnUIThread() { 169 DCHECK(!BrowserThread::IsThreadInitialized(BrowserThread::UI) || 170 BrowserThread::CurrentlyOn(BrowserThread::UI)); 171 notification_registrar_.RemoveAll(); 172} 173 174void ShortcutsBackend::Observe(int type, 175 const content::NotificationSource& source, 176 const content::NotificationDetails& details) { 177 if (!initialized()) 178 return; 179 180 if (type == extensions::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED) { 181 // When an extension is unloaded, we want to remove any Shortcuts associated 182 // with it. 183 DeleteShortcutsWithURL(content::Details<extensions::UnloadedExtensionInfo>( 184 details)->extension->url(), false); 185 return; 186 } 187 188 DCHECK_EQ(chrome::NOTIFICATION_HISTORY_URLS_DELETED, type); 189 const history::URLsDeletedDetails* deleted_details = 190 content::Details<const history::URLsDeletedDetails>(details).ptr(); 191 if (deleted_details->all_history) { 192 DeleteAllShortcuts(); 193 return; 194 } 195 196 const history::URLRows& rows(deleted_details->rows); 197 history::ShortcutsDatabase::ShortcutIDs shortcut_ids; 198 for (GuidMap::const_iterator it(guid_map_.begin()); it != guid_map_.end(); 199 ++it) { 200 if (std::find_if( 201 rows.begin(), rows.end(), history::URLRow::URLRowHasURL( 202 it->second->second.match_core.destination_url)) != rows.end()) 203 shortcut_ids.push_back(it->first); 204 } 205 DeleteShortcutsWithIDs(shortcut_ids); 206} 207 208void ShortcutsBackend::InitInternal() { 209 DCHECK(current_state_ == INITIALIZING); 210 db_->Init(); 211 history::ShortcutsDatabase::GuidToShortcutMap shortcuts; 212 db_->LoadShortcuts(&shortcuts); 213 temp_shortcuts_map_.reset(new ShortcutMap); 214 temp_guid_map_.reset(new GuidMap); 215 for (history::ShortcutsDatabase::GuidToShortcutMap::const_iterator it( 216 shortcuts.begin()); it != shortcuts.end(); ++it) { 217 (*temp_guid_map_)[it->first] = temp_shortcuts_map_->insert( 218 std::make_pair(base::i18n::ToLower(it->second.text), it->second)); 219 } 220 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, 221 base::Bind(&ShortcutsBackend::InitCompleted, this)); 222} 223 224void ShortcutsBackend::InitCompleted() { 225 temp_guid_map_->swap(guid_map_); 226 temp_shortcuts_map_->swap(shortcuts_map_); 227 temp_shortcuts_map_.reset(NULL); 228 temp_guid_map_.reset(NULL); 229 current_state_ = INITIALIZED; 230 FOR_EACH_OBSERVER(ShortcutsBackendObserver, observer_list_, 231 OnShortcutsLoaded()); 232} 233 234bool ShortcutsBackend::AddShortcut( 235 const history::ShortcutsDatabase::Shortcut& shortcut) { 236 if (!initialized()) 237 return false; 238 DCHECK(guid_map_.find(shortcut.id) == guid_map_.end()); 239 guid_map_[shortcut.id] = shortcuts_map_.insert( 240 std::make_pair(base::i18n::ToLower(shortcut.text), shortcut)); 241 FOR_EACH_OBSERVER(ShortcutsBackendObserver, observer_list_, 242 OnShortcutsChanged()); 243 return no_db_access_ || 244 BrowserThread::PostTask( 245 BrowserThread::DB, FROM_HERE, 246 base::Bind(base::IgnoreResult( 247 &history::ShortcutsDatabase::AddShortcut), 248 db_.get(), shortcut)); 249} 250 251bool ShortcutsBackend::UpdateShortcut( 252 const history::ShortcutsDatabase::Shortcut& shortcut) { 253 if (!initialized()) 254 return false; 255 GuidMap::iterator it(guid_map_.find(shortcut.id)); 256 if (it != guid_map_.end()) 257 shortcuts_map_.erase(it->second); 258 guid_map_[shortcut.id] = shortcuts_map_.insert( 259 std::make_pair(base::i18n::ToLower(shortcut.text), shortcut)); 260 FOR_EACH_OBSERVER(ShortcutsBackendObserver, observer_list_, 261 OnShortcutsChanged()); 262 return no_db_access_ || 263 BrowserThread::PostTask( 264 BrowserThread::DB, FROM_HERE, 265 base::Bind(base::IgnoreResult( 266 &history::ShortcutsDatabase::UpdateShortcut), 267 db_.get(), shortcut)); 268} 269 270bool ShortcutsBackend::DeleteShortcutsWithIDs( 271 const history::ShortcutsDatabase::ShortcutIDs& shortcut_ids) { 272 if (!initialized()) 273 return false; 274 for (size_t i = 0; i < shortcut_ids.size(); ++i) { 275 GuidMap::iterator it(guid_map_.find(shortcut_ids[i])); 276 if (it != guid_map_.end()) { 277 shortcuts_map_.erase(it->second); 278 guid_map_.erase(it); 279 } 280 } 281 FOR_EACH_OBSERVER(ShortcutsBackendObserver, observer_list_, 282 OnShortcutsChanged()); 283 return no_db_access_ || 284 BrowserThread::PostTask( 285 BrowserThread::DB, FROM_HERE, 286 base::Bind(base::IgnoreResult( 287 &history::ShortcutsDatabase::DeleteShortcutsWithIDs), 288 db_.get(), shortcut_ids)); 289} 290 291bool ShortcutsBackend::DeleteShortcutsWithURL(const GURL& url, 292 bool exact_match) { 293 const std::string& url_spec = url.spec(); 294 history::ShortcutsDatabase::ShortcutIDs shortcut_ids; 295 for (GuidMap::iterator it(guid_map_.begin()); it != guid_map_.end(); ) { 296 if (exact_match ? 297 (it->second->second.match_core.destination_url == url) : 298 StartsWithASCII(it->second->second.match_core.destination_url.spec(), 299 url_spec, true)) { 300 shortcut_ids.push_back(it->first); 301 shortcuts_map_.erase(it->second); 302 guid_map_.erase(it++); 303 } else { 304 ++it; 305 } 306 } 307 FOR_EACH_OBSERVER(ShortcutsBackendObserver, observer_list_, 308 OnShortcutsChanged()); 309 return no_db_access_ || 310 BrowserThread::PostTask( 311 BrowserThread::DB, FROM_HERE, 312 base::Bind(base::IgnoreResult( 313 &history::ShortcutsDatabase::DeleteShortcutsWithURL), 314 db_.get(), url_spec)); 315} 316 317bool ShortcutsBackend::DeleteAllShortcuts() { 318 if (!initialized()) 319 return false; 320 shortcuts_map_.clear(); 321 guid_map_.clear(); 322 FOR_EACH_OBSERVER(ShortcutsBackendObserver, observer_list_, 323 OnShortcutsChanged()); 324 return no_db_access_ || 325 BrowserThread::PostTask( 326 BrowserThread::DB, FROM_HERE, 327 base::Bind(base::IgnoreResult( 328 &history::ShortcutsDatabase::DeleteAllShortcuts), 329 db_.get())); 330} 331