Home | History | Annotate | Download | only in history 
      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