Move Time, TimeDelta and TimeTicks into namespace base.

net/base/cookie_monster.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.
 
 // Brought to you by the letter D and the number 2.
 
 #ifndef NET_BASE_COOKIE_MONSTER_H_
 #define NET_BASE_COOKIE_MONSTER_H_
 
 #include <map>
@@ skipping 53 matching lines @@
 
   // The store passed in should not have had Init() called on it yet. This class
   // will take care of initializing it. The backing store is NOT owned by this
   // class, but it must remain valid for the duration of the cookie monster's
   // existence.
   CookieMonster(PersistentCookieStore* store);
 
   ~CookieMonster();
 
   // Parse the string with the cookie time (very forgivingly).
-  static Time ParseCookieTime(const std::string& time_string);
+  static base::Time ParseCookieTime(const std::string& time_string);
 
   // Set a single cookie.  Expects a cookie line, like "a=1; domain=b.com".
   bool SetCookie(const GURL& url, const std::string& cookie_line);
   // Sets a single cookie with a specific creation date. To set a cookie with
   // a creation date of Now() use SetCookie() instead (it calls this function
   // internally).
   bool SetCookieWithCreationTime(const GURL& url,
                                  const std::string& cookie_line,
-                                 const Time& creation_time);
+                                 const base::Time& creation_time);
   // Set a vector of response cookie values for the same URL.
   void SetCookies(const GURL& url, const std::vector<std::string>& cookies);
 
   // TODO what if the total size of all the cookies >4k, can we have a header
   // that big or do we need multiple Cookie: headers?
   // Simple interface, get a cookie string "a=b; c=d" for the given URL.
   // It will _not_ return httponly cookies, see GetCookiesWithOptions
   std::string GetCookies(const GURL& url);
   std::string GetCookiesWithOptions(const GURL& url, CookieOptions options);
   // Returns all the cookies, for use in management UI, etc.
   CookieList GetAllCookies();
 
   // Delete all of the cookies.
   int DeleteAll(bool sync_to_store);
   // Delete all of the cookies that have a creation_date greater than or equal
   // to |delete_begin| and less than |delete_end|
-  int DeleteAllCreatedBetween(const Time& delete_begin,
-                              const Time& delete_end,
+  int DeleteAllCreatedBetween(const base::Time& delete_begin,
+                              const base::Time& delete_end,
                               bool sync_to_store);
   // Delete all of the cookies that have a creation_date more recent than the
   // one passed into the function via |delete_after|.
-  int DeleteAllCreatedAfter(const Time& delete_begin, bool sync_to_store);
+  int DeleteAllCreatedAfter(const base::Time& delete_begin, bool sync_to_store);
 
   // Delete one specific cookie.
   bool DeleteCookie(const std::string& domain,
                     const CanonicalCookie& cookie,
                     bool sync_to_store);
 
   // There are some unknowns about how to correctly handle file:// cookies,
   // and our implementation for this is not robust enough. This allows you
   // to enable support, but it should only be used for testing. Bug 1157243.
   static void EnableFileScheme();
@@ skipping 16 matching lines @@
   // Should only be called by InitIfNecessary().
   void InitStore();
 
   void FindCookiesForHostAndDomain(const GURL& url,
                                    CookieOptions options,
                                    std::vector<CanonicalCookie*>* cookies);
 
   void FindCookiesForKey(const std::string& key,
                          const GURL& url,
                          CookieOptions options,
-                         const Time& current,
+                         const base::Time& current,
                          std::vector<CanonicalCookie*>* cookies);
 
   int DeleteEquivalentCookies(const std::string& key,
                               const CanonicalCookie& ecc);
 
   void InternalInsertCookie(const std::string& key,
                             CanonicalCookie* cc,
                             bool sync_to_store);
 
   void InternalDeleteCookie(CookieMap::iterator it, bool sync_to_store);
 
   // Enforce cookie maximum limits, purging expired and old cookies if needed
-  int GarbageCollect(const Time& current, const std::string& key);
-  int GarbageCollectRange(const Time& current,
+  int GarbageCollect(const base::Time& current, const std::string& key);
+  int GarbageCollectRange(const base::Time& current,
                           const CookieMapItPair& itpair,
                           size_t num_max,
                           size_t num_purge);
 
   CookieMap cookies_;
 
   // Indicates whether the cookie store has been initialized. This happens
   // lazily in InitStoreIfNecessary().
   bool initialized_;
 
   PersistentCookieStore* store_;
 
   // The resolution of our time isn't enough, so we do something
   // ugly and increment when we've seen the same time twice.
-  Time CurrentTime();
-  Time last_time_seen_;
+  base::Time CurrentTime();
+  base::Time last_time_seen_;
 
   // Lock for thread-safety
   Lock lock_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieMonster);
 };
 
 class CookieMonster::ParsedCookie {
  public:
   typedef std::pair<std::string, std::string> TokenValuePair;
@@ skipping 47 matching lines @@
   size_t httponly_index_;
 
   DISALLOW_COPY_AND_ASSIGN(ParsedCookie);
 };
 
 
 class CookieMonster::CanonicalCookie {
  public:
   CanonicalCookie(const std::string& name, const std::string& value,
                   const std::string& path, bool secure,
-                  bool httponly, const Time& creation,
-                  bool has_expires, const Time& expires)
+                  bool httponly, const base::Time& creation,
+                  bool has_expires, const base::Time& expires)
       : name_(name),
         value_(value),
         path_(path),
         creation_date_(creation),
         expiry_date_(expires),
         has_expires_(has_expires),
         secure_(secure),
         httponly_(httponly) {
   }
 
 #if defined(_MSC_VER) && _CPPLIB_VER == 505
   // On Visual Studio 2008 Service Pack 1, std::vector<> do an early
   // optimization in a way that requires the availability of a default
   // constructor. It is because it sees std::pair<> as "swappable", so creates a
   // dummy to swap with, which requires an empty constructor for any entry in
   // the std::pair.
   CanonicalCookie() { }
 #endif
 
   // Supports the default copy constructor.
 
   const std::string& Name() const { return name_; }
   const std::string& Value() const { return value_; }
   const std::string& Path() const { return path_; }
-  const Time& CreationDate() const { return creation_date_; }
+  const base::Time& CreationDate() const { return creation_date_; }
   bool DoesExpire() const { return has_expires_; }
   bool IsPersistent() const { return DoesExpire(); }
-  const Time& ExpiryDate() const { return expiry_date_; }
+  const base::Time& ExpiryDate() const { return expiry_date_; }
   bool IsSecure() const { return secure_; }
   bool IsHttpOnly() const { return httponly_; }
 
-  bool IsExpired(const Time& current) {
+  bool IsExpired(const base::Time& current) {
     return has_expires_ && current >= expiry_date_;
   }
 
   // Are the cookies considered equivalent in the eyes of the RFC.
   // This says that the domain and path should string match identically.
   bool IsEquivalent(const CanonicalCookie& ecc) const {
     // It seems like it would make sense to take secure and httponly into
     // account, but the RFC doesn't specify this.
     return name_ == ecc.Name() && path_ == ecc.Path();
   }
 
   bool IsOnPath(const std::string& url_path) const;
 
   std::string DebugString() const;
  private:
   std::string name_;
   std::string value_;
   std::string path_;
-  Time creation_date_;
-  Time expiry_date_;
+  base::Time creation_date_;
+  base::Time expiry_date_;
   bool has_expires_;
   bool secure_;
   bool httponly_;
 };
 
 class CookieMonster::PersistentCookieStore {
  public:
   virtual ~PersistentCookieStore() { }
 
   // Initializes the store and retrieves the existing cookies. This will be
   // called only once at startup.
   virtual bool Load(std::vector<CookieMonster::KeyedCanonicalCookie>*) = 0;
 
   virtual void AddCookie(const std::string&, const CanonicalCookie&) = 0;
   virtual void DeleteCookie(const CanonicalCookie&) = 0;
 
  protected:
   PersistentCookieStore() { }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PersistentCookieStore);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_COOKIE_MONSTER_H_