shortcuts_backend.cc revision 1320f92c476a1ad9d19dba2a48c72b75566198e9 
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