Move Time, TimeDelta and TimeTicks into namespace base.

chrome/browser/history/history.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_HISTORY_H__
 #define CHROME_BROWSER_HISTORY_HISTORY_H__
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 145 matching lines @@
   void AddPage(const GURL& url,
                const void* id_scope,
                int32 page_id,
                const GURL& referrer,
                PageTransition::Type transition,
                const RedirectList& redirects);
 
   // For adding pages to history with a specific time. This is for testing
   // purposes. Call the previous one to use the current time.
   void AddPage(const GURL& url,
-               Time time,
+               base::Time time,
                const void* id_scope,
                int32 page_id,
                const GURL& referrer,
                PageTransition::Type transition,
                const RedirectList& redirects);
 
   // For adding pages to history where no tracking information can be done.
   void AddPage(const GURL& url) {
     AddPage(url, NULL, 0, GURL::EmptyGURL(), PageTransition::LINK,
             RedirectList());
@@ skipping 96 matching lines @@
   // Schedules a query for the most recent redirect coming out of the given
   // URL. See the RedirectQuerySource above, which is guaranteed to be called
   // if the request is not canceled.
   Handle QueryRedirectsFrom(const GURL& from_url,
                             CancelableRequestConsumerBase* consumer,
                             QueryRedirectsCallback* callback);
 
   typedef Callback4<Handle,
                     bool,        // Were we able to determine the # of visits?
                     int,         // Number of visits.
-                    Time>::Type  // Time of first visit. Only first bool is
+                    base::Time>::Type // Time of first visit. Only first bool is
                                  // true and int is > 0.
       GetVisitCountToHostCallback;
 
   // Requests the number of visits to all urls on the scheme/host/post
   // identified by url. This is only valid for http and https urls.
   Handle GetVisitCountToHost(const GURL& url,
                              CancelableRequestConsumerBase* consumer,
                              GetVisitCountToHostCallback* callback);
 
   // Thumbnails ----------------------------------------------------------------
@@ skipping 86 matching lines @@
   // Implemented by the caller of 'ExpireHistory(Since|Between)' below, and
   // is called when the history service has deleted the history.
   typedef Callback0::Type ExpireHistoryCallback;
 
   // Removes all visits in the selected time range (including the start time),
   // updating the URLs accordingly. This deletes the associated data, including
   // the full text index. This function also deletes the associated favicons,
   // if they are no longer referenced. |callback| runs when the expiration is
   // complete. You may use null Time values to do an unbounded delete in
   // either direction.
-  void ExpireHistoryBetween(Time begin_time, Time end_time,
+  void ExpireHistoryBetween(base::Time begin_time, base::Time end_time,
                             CancelableRequestConsumerBase* consumer,
                             ExpireHistoryCallback* callback);
 
   // Downloads -----------------------------------------------------------------
 
   // Implemented by the caller of 'CreateDownload' below, and is called when the
   // history service has created a new entry for a download in the history db.
   typedef Callback2<DownloadCreateInfo, int64>::Type DownloadCreateCallback;
 
   // Begins a history request to create a new persistent entry for a download.
@@ skipping 26 matching lines @@
 
   // Permanently remove a download from the history system. This is a 'fire and
   // forget' operation.
   void RemoveDownload(int64 db_handle);
 
   // Permanently removes all completed download from the history system within
   // the specified range. This function does not delete downloads that are in
   // progress or in the process of being cancelled. This is a 'fire and forget'
   // operation. You can pass is_null times to get unbounded time in either or
   // both directions.
-  void RemoveDownloadsBetween(Time remove_begin, Time remove_end);
+  void RemoveDownloadsBetween(base::Time remove_begin, base::Time remove_end);
 
   // Implemented by the caller of 'SearchDownloads' below, and is called when
   // the history system has retrieved the search results.
   typedef Callback2<Handle, std::vector<int64>*>::Type DownloadSearchCallback;
 
   // Search for downloads that match the search text.
   Handle SearchDownloads(const std::wstring& search_text,
                          CancelableRequestConsumerBase* consumer,
                          DownloadSearchCallback* callback);
 
   // Visit Segments ------------------------------------------------------------
 
   typedef Callback2<Handle, std::vector<PageUsageData*>*>::Type
       SegmentQueryCallback;
 
   // Query usage data for all visit segments since the provided time.
   //
   // The request is performed asynchronously and can be cancelled by using the
   // returned handle.
   //
   // The vector provided to the callback and its contents is owned by the
   // history system. It will be deeply deleted after the callback is invoked.
   // If you want to preserve any PageUsageData instance, simply remove them
   // from the vector.
   //
   // The vector contains a list of PageUsageData. Each PageUsageData ID is set
   // to the segment ID. The URL and all the other information is set to the page
   // representing the segment.
   Handle QuerySegmentUsageSince(CancelableRequestConsumerBase* consumer,
-                                const Time from_time,
+                                const base::Time from_time,
                                 SegmentQueryCallback* callback);
 
   // Set the presentation index for the segment identified by |segment_id|.
   void SetSegmentPresentationIndex(int64 segment_id, int index);
 
   // Keyword search terms -----------------------------------------------------
 
   // Sets the search terms for the specified url and keyword. url_id gives the
   // id of the url, keyword_id the id of the keyword and term the search term.
   void SetKeywordSearchTermsForURL(const GURL& url,
@@ skipping 48 matching lines @@
   // into the database. This assumes the URL doesn't exist in the database
   //
   // Calling this function many times may be slow because each call will
   // dispatch to the history thread and will be a separate database
   // transaction. If this functionality is needed for importing many URLs, a
   // version that takes an array should probably be added.
   void AddPageWithDetails(const GURL& url,
                           const std::wstring& title,
                           int visit_count,
                           int typed_count,
-                          Time last_visit,
+                          base::Time last_visit,
                           bool hidden);
 
   // The same as AddPageWithDetails() but takes a vector.
   void AddPagesWithDetails(const std::vector<history::URLRow>& info);
 
  private:
   class BackendDelegate;
   friend class BackendDelegate;
   friend class history::HistoryBackend;
   friend class history::HistoryQueryTest;
@@ skipping 210 matching lines @@
   Profile* profile_;
 
   // Has the backend finished loading? The backend is loaded once Init has
   // completed.
   bool backend_loaded_;
 
   DISALLOW_EVIL_CONSTRUCTORS(HistoryService);
 };
 
 #endif  // CHROME_BROWSER_HISTORY_HISTORY_H__