Home | History | Annotate | Download | only in autocomplete 
      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 
     36 using content::BrowserThread;
     37 
     38 namespace {
     39 
     40 // Takes Match classification vector and removes all matched positions,
     41 // compacting repetitions if necessary.
     42 std::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.
     55 AutocompleteMatch::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 
     76 ShortcutsBackend::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 
     96 bool 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 
    110 bool ShortcutsBackend::DeleteShortcutsWithURL(const GURL& shortcut_url) {
    111   return initialized() && DeleteShortcutsWithURL(shortcut_url, true);
    112 }
    113 
    114 void ShortcutsBackend::AddObserver(ShortcutsBackendObserver* obs) {
    115   observer_list_.AddObserver(obs);
    116 }
    117 
    118 void ShortcutsBackend::RemoveObserver(ShortcutsBackendObserver* obs) {
    119   observer_list_.RemoveObserver(obs);
    120 }
    121 
    122 void 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 
    141 ShortcutsBackend::~ShortcutsBackend() {
    142 }
    143 
    144 // static
    145 history::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 
    168 void ShortcutsBackend::ShutdownOnUIThread() {
    169   DCHECK(!BrowserThread::IsThreadInitialized(BrowserThread::UI) ||
    170          BrowserThread::CurrentlyOn(BrowserThread::UI));
    171   notification_registrar_.RemoveAll();
    172 }
    173 
    174 void 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 
    208 void 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 
    224 void 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 
    234 bool 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 
    251 bool 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 
    270 bool 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 
    291 bool 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 
    317 bool 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