Move Time, TimeDelta and TimeTicks into namespace base.

chrome/browser/history/text_database_manager.h

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef CHROME_BROWSER_HISTORY_TEXT_DATABASE_MANAGER_H__
 #define CHROME_BROWSER_HISTORY_TEXT_DATABASE_MANAGER_H__
 
 #include <set>
 #include <vector>
 
@@ skipping 77 matching lines @@
   // In normal operation, URLs will be added as the user visits them, the titles
   // and bodies will come in some time after that. These changes will be
   // automatically coalesced and added to the database some time in the future
   // using AddPageData().
   //
   // AddPageURL must be called for a given URL (+ its corresponding ID) before
   // either the title or body set. The visit ID specifies the visit that will
   // get updated to refer to the full text indexed information. The visit time
   // should be the time corresponding to that visit in the database.
   void AddPageURL(const GURL& url, URLID url_id, VisitID visit_id,
-                  Time visit_time);
+                  base::Time visit_time);
   void AddPageTitle(const GURL& url, const std::wstring& title);
   void AddPageContents(const GURL& url, const std::wstring& body);
 
   // Adds the given data to the appropriate database file, returning true on
   // success. The visit database row identified by |visit_id| will be updated
   // to refer to the full text index entry. If the visit ID is 0, the visit
   // database will not be updated.
   bool AddPageData(const GURL& url,
                    URLID url_id,
                    VisitID visit_id,
-                   Time visit_time,
+                   base::Time visit_time,
                    const std::wstring& title,
                    const std::wstring& body);
 
   // Deletes the instance of indexed data identified by the given time and URL.
   // Any changes will be tracked in the optional change set for use when calling
   // OptimizeChangedDatabases later. change_set can be NULL.
-  void DeletePageData(Time time, const GURL& url,
+  void DeletePageData(base::Time time, const GURL& url,
                       ChangeSet* change_set);
 
   // The text database manager keeps a list of changes that are made to the
   // file AddPageURL/Title/Body that may not be committed to the database yet.
   // This function removes entires from this list happening between the given
   // time range. It is called when the user clears their history for a time
   // range, and we don't want any of our data to "leak."
   //
   // Either or both times my be is_null to be unbounded in that direction. When
   // non-null, the range is [begin, end).
-  void DeleteFromUncommitted(Time begin, Time end);
+  void DeleteFromUncommitted(base::Time begin, base::Time end);
 
   // Same as DeleteFromUncommitted but for a single URL.
   void DeleteURLFromUncommitted(const GURL& url);
 
   // Deletes all full text search data by removing the files from the disk.
   // This must be called OUTSIDE of a transaction since it actually deletes the
   // files rather than messing with the database.
   void DeleteAll();
 
   // Calls optimize on all the databases identified in a given change set (see
   // the definition of ChangeSet above for more). Optimizing means that old data
   // will be removed rather than marked unused.
   void OptimizeChangedDatabases(const ChangeSet& change_set);
 
   // Executes the given query. See QueryOptions for more info on input.
   //
   // The results are filled into |results|, and the first time considered for
   // the output is in |first_time_searched| (see QueryResults for more).
   //
   // This function will return more than one match per URL if there is more than
   // one entry for that URL in the database.
   void GetTextMatches(const std::wstring& query,
                       const QueryOptions& options,
                       std::vector<TextDatabase::Match>* results,
-                      Time* first_time_searched);
+                      base::Time* first_time_searched);
 
  private:
   // These tests call ExpireRecentChangesForTime to force expiration.
   FRIEND_TEST(TextDatabaseManagerTest, InsertPartial);
   FRIEND_TEST(ExpireHistoryTest, DeleteURLAndFavicon);
   FRIEND_TEST(ExpireHistoryTest, FlushRecentURLsUnstarred);
 
   // Stores "recent stuff" that has happened with the page, since the page
   // visit, title, and body all come in at different times.
   class PageInfo {
    public:
-    PageInfo(URLID url_id, VisitID visit_id, Time visit_time);
+    PageInfo(URLID url_id, VisitID visit_id, base::Time visit_time);
 
     // Getters.
     URLID url_id() const { return url_id_; }
     VisitID visit_id() const { return visit_id_; }
-    Time visit_time() const { return visit_time_; }
+    base::Time visit_time() const { return visit_time_; }
     const std::wstring& title() const { return title_; }
     const std::wstring& body() const { return body_; }
 
     // Setters, we can only update the title and body.
     void set_title(const std::wstring& ttl);
     void set_body(const std::wstring& bdy);
 
     // Returns true if both the title or body of the entry has been set. Since
     // both the title and body setters will "fix" empty strings to be a space,
     // these indicate if the setter was ever called.
     bool has_title() const { return !title_.empty(); }
     bool has_body() { return !body_.empty(); }
 
     // Returns true if this entry was added too long ago and we should give up
     // waiting for more data. The current time is passed in as an argument so we
     // can check many without re-querying the timer.
-    bool Expired(TimeTicks now) const;
+    bool Expired(base::TimeTicks now) const;
 
    private:
     URLID url_id_;
     VisitID visit_id_;
 
     // Time of the visit of the URL. This will be the value stored in the URL
     // and visit tables for the entry.
-    Time visit_time_;
+    base::Time visit_time_;
 
     // When this page entry was created. We have a cap on the maximum time that
     // an entry will be in the queue before being flushed to the database.
-    TimeTicks added_time_;
+    base::TimeTicks added_time_;
 
     // Will be the string " " when they are set to distinguish set and unset.
     std::wstring title_;
     std::wstring body_;
   };
 
   // Converts the given time to a database identifier or vice-versa.
-  static TextDatabase::DBIdent TimeToID(Time time);
-  static Time IDToTime(TextDatabase::DBIdent id);
+  static TextDatabase::DBIdent TimeToID(base::Time time);
+  static base::Time IDToTime(TextDatabase::DBIdent id);
 
   // Returns a text database for the given identifier or time. This file will
   // be created if it doesn't exist and |for_writing| is set. On error,
   // including the case where the file doesn't exist and |for_writing|
   // is false, it will return NULL.
   //
   // When |for_writing| is set, a transaction on the database will be opened
   // if there is a transaction open on this manager.
   //
   // The pointer will be tracked in the cache. The caller should not store it
   // or delete it since it will get automatically deleted as necessary.
   TextDatabase* GetDB(TextDatabase::DBIdent id, bool for_writing);
-  TextDatabase* GetDBForTime(Time time, bool for_writing);
+  TextDatabase* GetDBForTime(base::Time time, bool for_writing);
 
   // Populates the present_databases_ list based on which files are on disk.
   // When the list is already initialized, this will do nothing, so you can
   // call it whenever you want to ensure the present_databases_ set is filled.
   void InitDBList();
 
   // Schedules a call to ExpireRecentChanges in the future.
   void ScheduleFlushOldChanges();
 
   // Checks the recent_changes_ list and commits partial data that has been
   // around too long.
   void FlushOldChanges();
 
   // Given "now," this will expire old things from the recent_changes_ list.
   // This is used as the backend for FlushOldChanges and is called directly
   // by the unit tests with fake times.
-  void FlushOldChangesForTime(TimeTicks now);
+  void FlushOldChangesForTime(base::TimeTicks now);
 
   // Directory holding our index files.
   const std::wstring dir_;
 
   // The database connection.
   sqlite3* db_;
   DBCloseScoper db_close_scoper_;
 
   // Non-owning pointers to the recent history databases for URLs and visits.
   VisitDatabase* visit_database_;
@@ skipping 42 matching lines @@
   // Generates tasks for our periodic checking of expired "recent changes".
   ScopedRunnableMethodFactory<TextDatabaseManager> factory_;
 
   DISALLOW_EVIL_CONSTRUCTORS(TextDatabaseManager);
 };
 
 }  // namespace history
 
 #endif  // CHROME_BROWSER_HISTORY_TEXT_DATABASE_MANAGER_H__