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 #ifndef CHROME_BROWSER_HISTORY_HISTORY_BACKEND_H_ 6 #define CHROME_BROWSER_HISTORY_HISTORY_BACKEND_H_ 7 8 #include <set> 9 #include <string> 10 #include <utility> 11 #include <vector> 12 13 #include "base/containers/mru_cache.h" 14 #include "base/files/file_path.h" 15 #include "base/gtest_prod_util.h" 16 #include "base/memory/memory_pressure_listener.h" 17 #include "base/memory/scoped_ptr.h" 18 #include "chrome/browser/history/expire_history_backend.h" 19 #include "chrome/browser/history/history_database.h" 20 #include "chrome/browser/history/history_marshaling.h" 21 #include "chrome/browser/history/history_types.h" 22 #include "chrome/browser/history/thumbnail_database.h" 23 #include "chrome/browser/history/visit_tracker.h" 24 #include "components/search_engines/template_url_id.h" 25 #include "sql/init_status.h" 26 27 class TestingProfile; 28 class TypedUrlSyncableService; 29 struct ThumbnailScore; 30 31 namespace history { 32 #if defined(OS_ANDROID) 33 class AndroidProviderBackend; 34 #endif 35 36 class CommitLaterTask; 37 class HistoryClient; 38 class VisitFilter; 39 struct DownloadRow; 40 41 // The maximum number of icons URLs per page which can be stored in the 42 // thumbnail database. 43 static const size_t kMaxFaviconsPerPage = 8; 44 45 // The maximum number of bitmaps for a single icon URL which can be stored in 46 // the thumbnail database. 47 static const size_t kMaxFaviconBitmapsPerIconURL = 8; 48 49 // *See the .cc file for more information on the design.* 50 // 51 // Internal history implementation which does most of the work of the history 52 // system. This runs on a background thread (to not block the browser when we 53 // do expensive operations) and is NOT threadsafe, so it must only be called 54 // from message handlers on the background thread. Invoking on another thread 55 // requires threadsafe refcounting. 56 // 57 // Most functions here are just the implementations of the corresponding 58 // functions in the history service. These functions are not documented 59 // here, see the history service for behavior. 60 class HistoryBackend : public base::RefCountedThreadSafe<HistoryBackend>, 61 public BroadcastNotificationDelegate { 62 public: 63 // Interface implemented by the owner of the HistoryBackend object. Normally, 64 // the history service implements this to send stuff back to the main thread. 65 // The unit tests can provide a different implementation if they don't have 66 // a history service object. 67 class Delegate { 68 public: 69 virtual ~Delegate() {} 70 71 // Called when the database cannot be read correctly for some reason. 72 virtual void NotifyProfileError(sql::InitStatus init_status) = 0; 73 74 // Sets the in-memory history backend. The in-memory backend is created by 75 // the main backend. For non-unit tests, this happens on the background 76 // thread. It is to be used on the main thread, so this would transfer 77 // it to the history service. Unit tests can override this behavior. 78 // 79 // This function is NOT guaranteed to be called. If there is an error, 80 // there may be no in-memory database. 81 virtual void SetInMemoryBackend( 82 scoped_ptr<InMemoryHistoryBackend> backend) = 0; 83 84 // Broadcasts the specified notification to the notification service. 85 // This is implemented here because notifications must only be sent from 86 // the main thread. This is the only method that doesn't identify the 87 // caller because notifications must always be sent. 88 virtual void BroadcastNotifications(int type, 89 scoped_ptr<HistoryDetails> details) = 0; 90 91 // Invoked when the backend has finished loading the db. 92 virtual void DBLoaded() = 0; 93 94 virtual void NotifyVisitDBObserversOnAddVisit( 95 const history::BriefVisitInfo& info) = 0; 96 }; 97 98 // QueryURLResult stores the result of a call to QueryURL. The |row| and 99 // |visits| fields are only valid if |success| is true. 100 struct QueryURLResult { 101 QueryURLResult(); 102 ~QueryURLResult(); 103 bool success; 104 URLRow row; 105 VisitVector visits; 106 }; 107 108 // Init must be called to complete object creation. This object can be 109 // constructed on any thread, but all other functions including Init() must 110 // be called on the history thread. 111 // 112 // |history_dir| is the directory where the history files will be placed. 113 // See the definition of BroadcastNotificationsCallback above. This function 114 // takes ownership of the callback pointer. 115 // 116 // |history_client| is used to determine bookmarked URLs when deleting and 117 // may be NULL. 118 // 119 // This constructor is fast and does no I/O, so can be called at any time. 120 HistoryBackend(const base::FilePath& history_dir, 121 Delegate* delegate, 122 HistoryClient* history_client); 123 124 // Must be called after creation but before any objects are created. If this 125 // fails, all other functions will fail as well. (Since this runs on another 126 // thread, we don't bother returning failure.) 127 // 128 // |languages| gives a list of language encodings with which the history 129 // URLs and omnibox searches are interpreted. 130 // |force_fail| can be set during unittests to unconditionally fail to init. 131 void Init(const std::string& languages, bool force_fail); 132 133 // Notification that the history system is shutting down. This will break 134 // the refs owned by the delegate and any pending transaction so it will 135 // actually be deleted. 136 void Closing(); 137 138 void ClearCachedDataForContextID(ContextID context_id); 139 140 // Navigation ---------------------------------------------------------------- 141 142 // |request.time| must be unique with high probability. 143 void AddPage(const HistoryAddPageArgs& request); 144 virtual void SetPageTitle(const GURL& url, const base::string16& title); 145 void AddPageNoVisitForBookmark(const GURL& url, const base::string16& title); 146 void UpdateWithPageEndTime(ContextID context_id, 147 int32 page_id, 148 const GURL& url, 149 base::Time end_ts); 150 151 // Querying ------------------------------------------------------------------ 152 153 // ScheduleAutocomplete() never frees |provider| (which is globally live). 154 // It passes |params| on to the autocomplete system which will eventually 155 // free it. 156 void ScheduleAutocomplete(HistoryURLProvider* provider, 157 HistoryURLProviderParams* params); 158 159 void IterateURLs( 160 const scoped_refptr<visitedlink::VisitedLinkDelegate::URLEnumerator>& 161 enumerator); 162 void QueryURL(const GURL& url, 163 bool want_visits, 164 QueryURLResult* query_url_result); 165 void QueryHistory(scoped_refptr<QueryHistoryRequest> request, 166 const base::string16& text_query, 167 const QueryOptions& options); 168 void QueryRedirectsFrom(scoped_refptr<QueryRedirectsRequest> request, 169 const GURL& url); 170 void QueryRedirectsTo(scoped_refptr<QueryRedirectsRequest> request, 171 const GURL& url); 172 173 void GetVisibleVisitCountToHost( 174 scoped_refptr<GetVisibleVisitCountToHostRequest> request, 175 const GURL& url); 176 177 // TODO(Nik): remove. Use QueryMostVisitedURLs instead. 178 void QueryTopURLsAndRedirects( 179 scoped_refptr<QueryTopURLsAndRedirectsRequest> request, 180 int result_count); 181 182 // Request the |result_count| most visited URLs and the chain of 183 // redirects leading to each of these URLs. |days_back| is the 184 // number of days of history to use. Used by TopSites. 185 void QueryMostVisitedURLs( 186 scoped_refptr<QueryMostVisitedURLsRequest> request, 187 int result_count, 188 int days_back); 189 190 // Request the |result_count| URLs and the chain of redirects 191 // leading to each of these URLs, filterd and sorted based on the |filter|. 192 // If |debug| is enabled, additional data will be computed and provided. 193 void QueryFilteredURLs( 194 scoped_refptr<QueryFilteredURLsRequest> request, 195 int result_count, 196 const history::VisitFilter& filter, 197 bool debug); 198 199 // QueryMostVisitedURLs without the request. 200 void QueryMostVisitedURLsImpl(int result_count, 201 int days_back, 202 MostVisitedURLList* result); 203 204 // Computes the most recent URL(s) that the given canonical URL has 205 // redirected to and returns true on success. There may be more than one 206 // redirect in a row, so this function will fill the given array with the 207 // entire chain. If there are no redirects for the most recent visit of the 208 // URL, or the URL is not in history, returns false. 209 // 210 // Backend for QueryRedirectsFrom. 211 bool GetMostRecentRedirectsFrom(const GURL& url, 212 history::RedirectList* redirects); 213 214 // Similar to above function except computes a chain of redirects to the 215 // given URL. Stores the most recent list of redirects ending at |url| in the 216 // given RedirectList. For example, if we have the redirect list A -> B -> C, 217 // then calling this function with url=C would fill redirects with {B, A}. 218 bool GetMostRecentRedirectsTo(const GURL& url, 219 history::RedirectList* redirects); 220 221 // Favicon ------------------------------------------------------------------- 222 223 void GetFavicons( 224 const std::vector<GURL>& icon_urls, 225 int icon_types, 226 const std::vector<int>& desired_sizes, 227 std::vector<favicon_base::FaviconRawBitmapResult>* bitmap_results); 228 229 void GetLargestFaviconForURL( 230 const GURL& page_url, 231 const std::vector<int>& icon_types, 232 int minimum_size_in_pixels, 233 favicon_base::FaviconRawBitmapResult* bitmap_result); 234 235 void GetFaviconsForURL( 236 const GURL& page_url, 237 int icon_types, 238 const std::vector<int>& desired_sizes, 239 std::vector<favicon_base::FaviconRawBitmapResult>* bitmap_results); 240 241 void GetFaviconForID( 242 favicon_base::FaviconID favicon_id, 243 int desired_size, 244 std::vector<favicon_base::FaviconRawBitmapResult>* bitmap_results); 245 246 void UpdateFaviconMappingsAndFetch( 247 const GURL& page_url, 248 const std::vector<GURL>& icon_urls, 249 int icon_types, 250 const std::vector<int>& desired_sizes, 251 std::vector<favicon_base::FaviconRawBitmapResult>* bitmap_results); 252 253 void MergeFavicon(const GURL& page_url, 254 const GURL& icon_url, 255 favicon_base::IconType icon_type, 256 scoped_refptr<base::RefCountedMemory> bitmap_data, 257 const gfx::Size& pixel_size); 258 259 void SetFavicons(const GURL& page_url, 260 favicon_base::IconType icon_type, 261 const std::vector<favicon_base::FaviconRawBitmapData>& 262 favicon_bitmap_data); 263 264 void SetFaviconsOutOfDateForPage(const GURL& page_url); 265 266 void CloneFavicons(const GURL& old_page_url, const GURL& new_page_url); 267 268 void SetImportedFavicons( 269 const std::vector<ImportedFaviconUsage>& favicon_usage); 270 271 // Downloads ----------------------------------------------------------------- 272 273 uint32 GetNextDownloadId(); 274 void QueryDownloads(std::vector<DownloadRow>* rows); 275 void UpdateDownload(const DownloadRow& data); 276 bool CreateDownload(const history::DownloadRow& history_info); 277 void RemoveDownloads(const std::set<uint32>& ids); 278 279 // Segment usage ------------------------------------------------------------- 280 281 void QuerySegmentUsage(scoped_refptr<QuerySegmentUsageRequest> request, 282 const base::Time from_time, 283 int max_result_count); 284 void DeleteOldSegmentData(); 285 286 // Keyword search terms ------------------------------------------------------ 287 288 void SetKeywordSearchTermsForURL(const GURL& url, 289 TemplateURLID keyword_id, 290 const base::string16& term); 291 292 void DeleteAllSearchTermsForKeyword(TemplateURLID keyword_id); 293 294 void GetMostRecentKeywordSearchTerms( 295 scoped_refptr<GetMostRecentKeywordSearchTermsRequest> request, 296 TemplateURLID keyword_id, 297 const base::string16& prefix, 298 int max_count); 299 300 void DeleteKeywordSearchTermForURL(const GURL& url); 301 302 void DeleteMatchingURLsForKeyword(TemplateURLID keyword_id, 303 const base::string16& term); 304 305 #if defined(OS_ANDROID) 306 // Android Provider --------------------------------------------------------- 307 308 // History and bookmarks ---------------------------------------------------- 309 void InsertHistoryAndBookmark(scoped_refptr<InsertRequest> request, 310 const HistoryAndBookmarkRow& row); 311 312 void QueryHistoryAndBookmarks( 313 scoped_refptr<QueryRequest> request, 314 const std::vector<HistoryAndBookmarkRow::ColumnID>& projections, 315 const std::string& selection, 316 const std::vector<base::string16>& selection_args, 317 const std::string& sort_order); 318 319 void UpdateHistoryAndBookmarks( 320 scoped_refptr<UpdateRequest> request, 321 const HistoryAndBookmarkRow& row, 322 const std::string& selection, 323 const std::vector<base::string16>& selection_args); 324 325 void DeleteHistoryAndBookmarks( 326 scoped_refptr<DeleteRequest> request, 327 const std::string& selection, 328 const std::vector<base::string16>& selection_args); 329 330 void DeleteHistory(scoped_refptr<DeleteRequest> request, 331 const std::string& selection, 332 const std::vector<base::string16>& selection_args); 333 334 // Statement ---------------------------------------------------------------- 335 // Move the statement's current position. 336 void MoveStatement(scoped_refptr<MoveStatementRequest> request, 337 history::AndroidStatement* statement, 338 int current_pos, 339 int destination); 340 341 // Close the given statement. The ownership is transfered. 342 void CloseStatement(AndroidStatement* statement); 343 344 // Search terms ------------------------------------------------------------- 345 void InsertSearchTerm(scoped_refptr<InsertRequest> request, 346 const SearchRow& row); 347 348 void UpdateSearchTerms(scoped_refptr<UpdateRequest> request, 349 const SearchRow& row, 350 const std::string& selection, 351 const std::vector<base::string16> selection_args); 352 353 void DeleteSearchTerms(scoped_refptr<DeleteRequest> request, 354 const std::string& selection, 355 const std::vector<base::string16> selection_args); 356 357 void QuerySearchTerms(scoped_refptr<QueryRequest> request, 358 const std::vector<SearchRow::ColumnID>& projections, 359 const std::string& selection, 360 const std::vector<base::string16>& selection_args, 361 const std::string& sort_order); 362 363 #endif // defined(OS_ANDROID) 364 365 // Generic operations -------------------------------------------------------- 366 367 void ProcessDBTask(scoped_refptr<HistoryDBTaskRequest> request); 368 369 virtual bool GetAllTypedURLs(URLRows* urls); 370 371 virtual bool GetVisitsForURL(URLID id, VisitVector* visits); 372 373 // Fetches up to |max_visits| most recent visits for the passed URL. 374 virtual bool GetMostRecentVisitsForURL(URLID id, 375 int max_visits, 376 VisitVector* visits); 377 378 virtual bool UpdateURL(URLID id, const history::URLRow& url); 379 380 // While adding visits in batch, the source needs to be provided. 381 virtual bool AddVisits(const GURL& url, 382 const std::vector<history::VisitInfo>& visits, 383 VisitSource visit_source); 384 385 virtual bool RemoveVisits(const VisitVector& visits); 386 387 // Returns the VisitSource associated with each one of the passed visits. 388 // If there is no entry in the map for a given visit, that means the visit 389 // was SOURCE_BROWSED. Returns false if there is no HistoryDatabase.. 390 bool GetVisitsSource(const VisitVector& visits, VisitSourceMap* sources); 391 392 virtual bool GetURL(const GURL& url, history::URLRow* url_row); 393 394 // Returns the syncable service for syncing typed urls. The returned service 395 // is owned by |this| object. 396 virtual TypedUrlSyncableService* GetTypedUrlSyncableService() const; 397 398 // Deleting ------------------------------------------------------------------ 399 400 virtual void DeleteURLs(const std::vector<GURL>& urls); 401 402 virtual void DeleteURL(const GURL& url); 403 404 // Calls ExpireHistoryBackend::ExpireHistoryBetween and commits the change. 405 void ExpireHistoryBetween( 406 const std::set<GURL>& restrict_urls, 407 base::Time begin_time, 408 base::Time end_time); 409 410 // Finds the URLs visited at |times| and expires all their visits within 411 // [|begin_time|, |end_time|). All times in |times| should be in 412 // [|begin_time|, |end_time|). This is used when expiration request is from 413 // server side, i.e. web history deletes, where only visit times (possibly 414 // incomplete) are transmitted to protect user's privacy. 415 void ExpireHistoryForTimes(const std::set<base::Time>& times, 416 base::Time begin_time, base::Time end_time); 417 418 // Calls ExpireHistoryBetween() once for each element in the vector. 419 // The fields of |ExpireHistoryArgs| map directly to the arguments of 420 // of ExpireHistoryBetween(). 421 void ExpireHistory(const std::vector<ExpireHistoryArgs>& expire_list); 422 423 // Bookmarks ----------------------------------------------------------------- 424 425 // Notification that a URL is no longer bookmarked. If there are no visits 426 // for the specified url, it is deleted. 427 void URLsNoLongerBookmarked(const std::set<GURL>& urls); 428 429 // Callbacks To Kill Database When It Gets Corrupted ------------------------- 430 431 // Called by the database to report errors. Schedules one call to 432 // KillHistoryDatabase() in case of corruption. 433 void DatabaseErrorCallback(int error, sql::Statement* stmt); 434 435 // Raze the history database. It will be recreated in a future run. Hopefully 436 // things go better then. Continue running but without reading or storing any 437 // state into the HistoryBackend databases. Close all of the databases managed 438 // HistoryBackend as there are no provisions for accessing the other databases 439 // managed by HistoryBackend when the history database cannot be accessed. 440 void KillHistoryDatabase(); 441 442 // Testing ------------------------------------------------------------------- 443 444 // Sets the task to run and the message loop to run it on when this object 445 // is destroyed. See HistoryService::SetOnBackendDestroyTask for a more 446 // complete description. 447 void SetOnBackendDestroyTask(base::MessageLoop* message_loop, 448 const base::Closure& task); 449 450 // Adds the given rows to the database if it doesn't exist. A visit will be 451 // added for each given URL at the last visit time in the URLRow if the 452 // passed visit type != SOURCE_SYNCED (the sync code manages visits itself). 453 // Each visit will have the visit_source type set. 454 void AddPagesWithDetails(const URLRows& info, VisitSource visit_source); 455 456 #if defined(UNIT_TEST) 457 HistoryDatabase* db() const { return db_.get(); } 458 459 ExpireHistoryBackend* expire_backend() { return &expirer_; } 460 #endif 461 462 // Returns true if the passed visit time is already expired (used by the sync 463 // code to avoid syncing visits that would immediately be expired). 464 virtual bool IsExpiredVisitTime(const base::Time& time); 465 466 base::Time GetFirstRecordedTimeForTest() { 467 return first_recorded_time_; 468 } 469 470 protected: 471 virtual ~HistoryBackend(); 472 473 private: 474 friend class base::RefCountedThreadSafe<HistoryBackend>; 475 friend class CommitLaterTask; // The commit task needs to call Commit(). 476 friend class HistoryBackendTest; 477 friend class HistoryBackendDBTest; // So the unit tests can poke our innards. 478 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, DeleteAll); 479 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, DeleteAllThenAddData); 480 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, AddPagesWithDetails); 481 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, ImportedFaviconsTest); 482 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, URLsNoLongerBookmarked); 483 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, StripUsernamePasswordTest); 484 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, DeleteThumbnailsDatabaseTest); 485 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, AddPageVisitSource); 486 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, AddPageVisitNotLastVisit); 487 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, 488 AddPageVisitFiresNotificationWithCorrectDetails); 489 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, AddPageArgsSource); 490 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, AddVisitsSource); 491 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, GetMostRecentVisits); 492 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, RemoveVisitsSource); 493 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, RemoveVisitsTransitions); 494 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, MigrationVisitSource); 495 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, 496 SetFaviconMappingsForPageAndRedirects); 497 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, 498 SetFaviconMappingsForPageDuplicates); 499 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, SetFaviconsDeleteBitmaps); 500 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, SetFaviconsReplaceBitmapData); 501 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, 502 SetFaviconsSameFaviconURLForTwoPages); 503 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, 504 UpdateFaviconMappingsAndFetchNoChange); 505 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, MergeFaviconPageURLNotInDB); 506 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, MergeFaviconPageURLInDB); 507 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, MergeFaviconMaxFaviconsPerPage); 508 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, 509 MergeFaviconIconURLMappedToDifferentPageURL); 510 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, 511 MergeFaviconMaxFaviconBitmapsPerIconURL); 512 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, 513 UpdateFaviconMappingsAndFetchMultipleIconTypes); 514 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, GetFaviconsFromDBEmpty); 515 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, 516 GetFaviconsFromDBNoFaviconBitmaps); 517 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, 518 GetFaviconsFromDBSelectClosestMatch); 519 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, GetFaviconsFromDBSingleIconURL); 520 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, GetFaviconsFromDBIconType); 521 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, GetFaviconsFromDBExpired); 522 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, 523 UpdateFaviconMappingsAndFetchNoDB); 524 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, 525 CloneFaviconIsRestrictedToSameDomain); 526 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, QueryFilteredURLs); 527 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, UpdateVisitDuration); 528 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, ExpireHistoryForTimes); 529 FRIEND_TEST_ALL_PREFIXES(HistoryBackendTest, DeleteFTSIndexDatabases); 530 531 friend class ::TestingProfile; 532 533 // Computes the name of the specified database on disk. 534 base::FilePath GetArchivedFileName() const; 535 base::FilePath GetThumbnailFileName() const; 536 537 // Returns the name of the Favicons database. This is the new name 538 // of the Thumbnails database. 539 base::FilePath GetFaviconsFileName() const; 540 541 #if defined(OS_ANDROID) 542 // Returns the name of android cache database. 543 base::FilePath GetAndroidCacheFileName() const; 544 545 // Populate a map from a |MostVisitedURLList|. The map assigns a rank to each 546 // top URL and its redirects. This should only be done once at backend 547 // initialization. 548 // This can be removed for M31. (See issue 248761.) 549 550 void PopulateMostVisitedURLMap(); 551 // Record counts of page visits by rank. If a url is not ranked, record the 552 // page visit in a slot corresponding to |max_top_url_count|, which should 553 // be one greater than the largest rank of any url in |top_urls|. 554 // This can be removed for M31. (See issue 248761.) 555 void RecordTopPageVisitStats(const GURL& url); 556 #endif 557 558 class URLQuerier; 559 friend class URLQuerier; 560 561 // Does the work of Init. 562 void InitImpl(const std::string& languages); 563 564 // Called when the system is under memory pressure. 565 void OnMemoryPressure( 566 base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level); 567 568 // Closes all databases managed by HistoryBackend. Commits any pending 569 // transactions. 570 void CloseAllDatabases(); 571 572 // Adds a single visit to the database, updating the URL information such 573 // as visit and typed count. The visit ID of the added visit and the URL ID 574 // of the associated URL (whether added or not) is returned. Both values will 575 // be 0 on failure. 576 // 577 // This does not schedule database commits, it is intended to be used as a 578 // subroutine for AddPage only. It also assumes the database is valid. 579 std::pair<URLID, VisitID> AddPageVisit(const GURL& url, 580 base::Time time, 581 VisitID referring_visit, 582 content::PageTransition transition, 583 VisitSource visit_source); 584 585 // Returns a redirect chain in |redirects| for the VisitID 586 // |cur_visit|. |cur_visit| is assumed to be valid. Assumes that 587 // this HistoryBackend object has been Init()ed successfully. 588 void GetRedirectsFromSpecificVisit( 589 VisitID cur_visit, history::RedirectList* redirects); 590 591 // Similar to the above function except returns a redirect list ending 592 // at |cur_visit|. 593 void GetRedirectsToSpecificVisit( 594 VisitID cur_visit, history::RedirectList* redirects); 595 596 // Update the visit_duration information in visits table. 597 void UpdateVisitDuration(VisitID visit_id, const base::Time end_ts); 598 599 // Querying ------------------------------------------------------------------ 600 601 // Backends for QueryHistory. *Basic() handles queries that are not 602 // text search queries and can just be given directly to the history DB. 603 // The *Text() version performs a brute force query of the history DB to 604 // search for results which match the given text query. 605 // Both functions assume QueryHistory already checked the DB for validity. 606 void QueryHistoryBasic(const QueryOptions& options, QueryResults* result); 607 void QueryHistoryText(const base::string16& text_query, 608 const QueryOptions& options, 609 QueryResults* result); 610 611 // Committing ---------------------------------------------------------------- 612 613 // We always keep a transaction open on the history database so that multiple 614 // transactions can be batched. Periodically, these are flushed (use 615 // ScheduleCommit). This function does the commit to write any new changes to 616 // disk and opens a new transaction. This will be called automatically by 617 // ScheduleCommit, or it can be called explicitly if a caller really wants 618 // to write something to disk. 619 void Commit(); 620 621 // Schedules a commit to happen in the future. We do this so that many 622 // operations over a period of time will be batched together. If there is 623 // already a commit scheduled for the future, this will do nothing. 624 void ScheduleCommit(); 625 626 // Cancels the scheduled commit, if any. If there is no scheduled commit, 627 // does nothing. 628 void CancelScheduledCommit(); 629 630 // Segments ------------------------------------------------------------------ 631 632 // Walks back a segment chain to find the last visit with a non null segment 633 // id and returns it. If there is none found, returns 0. 634 SegmentID GetLastSegmentID(VisitID from_visit); 635 636 // Update the segment information. This is called internally when a page is 637 // added. Return the segment id of the segment that has been updated. 638 SegmentID UpdateSegments(const GURL& url, 639 VisitID from_visit, 640 VisitID visit_id, 641 content::PageTransition transition_type, 642 const base::Time ts); 643 644 // Favicons ------------------------------------------------------------------ 645 646 // Used by both UpdateFaviconMappingsAndFetch and GetFavicons. 647 // If |page_url| is non-null, the icon urls for |page_url| (and all 648 // redirects) are set to the subset of |icon_urls| for which icons are 649 // already stored in the database. 650 // If |page_url| is non-null, |icon_types| can be multiple icon types 651 // only if |icon_types| == TOUCH_ICON | TOUCH_PRECOMPOSED_ICON. 652 // If multiple icon types are specified, |page_url| will be mapped to the 653 // icon URLs of the largest type available in the database. 654 void UpdateFaviconMappingsAndFetchImpl( 655 const GURL* page_url, 656 const std::vector<GURL>& icon_urls, 657 int icon_types, 658 const std::vector<int>& desired_sizes, 659 std::vector<favicon_base::FaviconRawBitmapResult>* results); 660 661 // Set the favicon bitmaps for |icon_id|. 662 // For each entry in |favicon_bitmap_data|, if a favicon bitmap already 663 // exists at the entry's pixel size, replace the favicon bitmap's data with 664 // the entry's bitmap data. Otherwise add a new favicon bitmap. 665 // Any favicon bitmaps already mapped to |icon_id| whose pixel sizes are not 666 // in |favicon_bitmap_data| are deleted. 667 // If not NULL, |favicon_bitmaps_changed| is set to whether any of the bitmap 668 // data at |icon_id| is changed as a result of calling this method. 669 // Computing |favicon_bitmaps_changed| requires additional database queries 670 // so should be avoided if unnecessary. 671 void SetFaviconBitmaps(favicon_base::FaviconID icon_id, 672 const std::vector<favicon_base::FaviconRawBitmapData>& 673 favicon_bitmap_data, 674 bool* favicon_bitmaps_changed); 675 676 // Returns true if |favicon_bitmap_data| passed to SetFavicons() is valid. 677 // Criteria: 678 // 1) |favicon_bitmap_data| contains no more than 679 // kMaxFaviconsPerPage unique icon URLs. 680 // kMaxFaviconBitmapsPerIconURL favicon bitmaps for each icon URL. 681 // 2) FaviconRawBitmapData::bitmap_data contains non NULL bitmap data. 682 bool ValidateSetFaviconsParams(const std::vector< 683 favicon_base::FaviconRawBitmapData>& favicon_bitmap_data) const; 684 685 // Returns true if the bitmap data at |bitmap_id| equals |new_bitmap_data|. 686 bool IsFaviconBitmapDataEqual( 687 FaviconBitmapID bitmap_id, 688 const scoped_refptr<base::RefCountedMemory>& new_bitmap_data); 689 690 // Returns true if there are favicons for |page_url| and one of the types in 691 // |icon_types|. 692 // |favicon_bitmap_results| is set to the favicon bitmaps whose edge sizes 693 // most closely match |desired_sizes|. If |desired_sizes| has a '0' entry, the 694 // largest favicon bitmap with one of the icon types in |icon_types| is 695 // returned. If |icon_types| contains multiple icon types and there are 696 // several matched icon types in the database, results will only be returned 697 // for a single icon type in the priority of TOUCH_PRECOMPOSED_ICON, 698 // TOUCH_ICON, and FAVICON. See the comment for 699 // GetFaviconResultsForBestMatch() for more details on how 700 // |favicon_bitmap_results| is constructed. 701 bool GetFaviconsFromDB( 702 const GURL& page_url, 703 int icon_types, 704 const std::vector<int>& desired_sizes, 705 std::vector<favicon_base::FaviconRawBitmapResult>* 706 favicon_bitmap_results); 707 708 // Returns the favicon bitmaps whose edge sizes most closely match 709 // |desired_sizes| in |favicon_bitmap_results|. If |desired_sizes| has a '0' 710 // entry, only the largest favicon bitmap is returned. Goodness is computed 711 // via SelectFaviconFrameIndices(). It is computed on a per FaviconID basis, 712 // thus all |favicon_bitmap_results| are guaranteed to be for the same 713 // FaviconID. |favicon_bitmap_results| will have at most one entry for each 714 // desired edge size. There will be fewer entries if the same favicon bitmap 715 // is the best result for multiple edge sizes. 716 // Returns true if there were no errors. 717 bool GetFaviconBitmapResultsForBestMatch( 718 const std::vector<favicon_base::FaviconID>& candidate_favicon_ids, 719 const std::vector<int>& desired_sizes, 720 std::vector<favicon_base::FaviconRawBitmapResult>* 721 favicon_bitmap_results); 722 723 // Maps the favicon ids in |icon_ids| to |page_url| (and all redirects) 724 // for |icon_type|. 725 // Returns true if the mappings for the page or any of its redirects were 726 // changed. 727 bool SetFaviconMappingsForPageAndRedirects( 728 const GURL& page_url, 729 favicon_base::IconType icon_type, 730 const std::vector<favicon_base::FaviconID>& icon_ids); 731 732 // Maps the favicon ids in |icon_ids| to |page_url| for |icon_type|. 733 // Returns true if the function changed some of |page_url|'s mappings. 734 bool SetFaviconMappingsForPage( 735 const GURL& page_url, 736 favicon_base::IconType icon_type, 737 const std::vector<favicon_base::FaviconID>& icon_ids); 738 739 // Returns all the page URLs in the redirect chain for |page_url|. If there 740 // are no known redirects for |page_url|, returns a vector with |page_url|. 741 void GetCachedRecentRedirects(const GURL& page_url, 742 history::RedirectList* redirect_list); 743 744 // Send notification that the favicon has changed for |page_url| and all its 745 // redirects. 746 void SendFaviconChangedNotificationForPageAndRedirects( 747 const GURL& page_url); 748 749 // Generic stuff ------------------------------------------------------------- 750 751 // Processes the next scheduled HistoryDBTask, scheduling this method 752 // to be invoked again if there are more tasks that need to run. 753 void ProcessDBTaskImpl(); 754 755 // Release all tasks in history_db_tasks_ and clears it. 756 void ReleaseDBTasks(); 757 758 virtual void BroadcastNotifications( 759 int type, 760 scoped_ptr<HistoryDetails> details) OVERRIDE; 761 virtual void NotifySyncURLsModified(URLRows* rows) OVERRIDE; 762 virtual void NotifySyncURLsDeleted(bool all_history, 763 bool expired, 764 URLRows* rows) OVERRIDE; 765 766 // Deleting all history ------------------------------------------------------ 767 768 // Deletes all history. This is a special case of deleting that is separated 769 // from our normal dependency-following method for performance reasons. The 770 // logic lives here instead of ExpireHistoryBackend since it will cause 771 // re-initialization of some databases (e.g. Thumbnails) that could fail. 772 // When these databases are not valid, our pointers must be NULL, so we need 773 // to handle this type of operation to keep the pointers in sync. 774 void DeleteAllHistory(); 775 776 // Given a vector of all URLs that we will keep, removes all thumbnails 777 // referenced by any URL, and also all favicons that aren't used by those 778 // URLs. 779 bool ClearAllThumbnailHistory(const URLRows& kept_urls); 780 781 // Deletes all information in the history database, except for the supplied 782 // set of URLs in the URL table (these should correspond to the bookmarked 783 // URLs). 784 // 785 // The IDs of the URLs may change. 786 bool ClearAllMainHistory(const URLRows& kept_urls); 787 788 // Deletes the FTS index database files, which are no longer used. 789 void DeleteFTSIndexDatabases(); 790 791 // Returns the HistoryClient, blocking until the bookmarks are loaded. This 792 // may return NULL during testing. 793 HistoryClient* GetHistoryClient(); 794 795 // Notify any observers of an addition to the visit database. 796 void NotifyVisitObservers(const VisitRow& visit); 797 798 // Data ---------------------------------------------------------------------- 799 800 // Delegate. See the class definition above for more information. This will 801 // be NULL before Init is called and after Cleanup, but is guaranteed 802 // non-NULL in between. 803 scoped_ptr<Delegate> delegate_; 804 805 // Directory where database files will be stored. 806 base::FilePath history_dir_; 807 808 // The history/thumbnail databases. Either MAY BE NULL if the database could 809 // not be opened, all users must first check for NULL and return immediately 810 // if it is. The thumbnail DB may be NULL when the history one isn't, but not 811 // vice-versa. 812 scoped_ptr<HistoryDatabase> db_; 813 bool scheduled_kill_db_; // Database is being killed due to error. 814 scoped_ptr<ThumbnailDatabase> thumbnail_db_; 815 816 // Manages expiration between the various databases. 817 ExpireHistoryBackend expirer_; 818 819 // A commit has been scheduled to occur sometime in the future. We can check 820 // non-null-ness to see if there is a commit scheduled in the future, and we 821 // can use the pointer to cancel the scheduled commit. There can be only one 822 // scheduled commit at a time (see ScheduleCommit). 823 scoped_refptr<CommitLaterTask> scheduled_commit_; 824 825 // Maps recent redirect destination pages to the chain of redirects that 826 // brought us to there. Pages that did not have redirects or were not the 827 // final redirect in a chain will not be in this list, as well as pages that 828 // redirected "too long" ago (as determined by ExpireOldRedirects above). 829 // It is used to set titles & favicons for redirects to that of the 830 // destination. 831 // 832 // As with AddPage, the last item in the redirect chain will be the 833 // destination of the redirect (i.e., the key into recent_redirects_); 834 typedef base::MRUCache<GURL, history::RedirectList> RedirectCache; 835 RedirectCache recent_redirects_; 836 837 // Timestamp of the first entry in our database. 838 base::Time first_recorded_time_; 839 840 // When set, this is the task that should be invoked on destruction. 841 base::MessageLoop* backend_destroy_message_loop_; 842 base::Closure backend_destroy_task_; 843 844 // Tracks page transition types. 845 VisitTracker tracker_; 846 847 // A boolean variable to track whether we have already purged obsolete segment 848 // data. 849 bool segment_queried_; 850 851 // HistoryDBTasks to run. Be sure to AddRef when adding, and Release when 852 // done. 853 std::list<HistoryDBTaskRequest*> db_task_requests_; 854 855 // Used to determine if a URL is bookmarked; may be NULL. 856 // 857 // Use GetHistoryClient to access this, which makes sure the bookmarks are 858 // loaded before returning. 859 HistoryClient* history_client_; 860 861 #if defined(OS_ANDROID) 862 // Used to provide the Android ContentProvider APIs. 863 scoped_ptr<AndroidProviderBackend> android_provider_backend_; 864 865 // Used to provide UMA on the number of page visits that are to the most 866 // visited URLs. This is here because the backend both has access to this 867 // information and is notified of page visits. The top sites service should 868 // be used instead whenever possible. 869 std::map<GURL, int> most_visited_urls_map_; 870 #endif 871 872 // Used to manage syncing of the typed urls datatype. This will be NULL 873 // before Init is called. 874 scoped_ptr<TypedUrlSyncableService> typed_url_syncable_service_; 875 876 // Listens for the system being under memory pressure. 877 scoped_ptr<base::MemoryPressureListener> memory_pressure_listener_; 878 879 DISALLOW_COPY_AND_ASSIGN(HistoryBackend); 880 }; 881 882 } // namespace history 883 884 #endif // CHROME_BROWSER_HISTORY_HISTORY_BACKEND_H_ 885
