Remove the old synchronous CookieMonster API.

net/base/cookie_monster.h

 // Copyright (c) 2011 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_
 #pragma once
 
+#include <deque>
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/message_loop_proxy.h"

[erikwright (departed), 2011/08/11 13:58:24]

Why is this added here?

[ycxiao, 2011/08/12 02:35:24]

I think I can move this to .cc, and added an "class base::MessageLoopProxy"
declaration. 

 #include "base/synchronization/lock.h"
 #include "base/task.h"
 #include "base/time.h"
 #include "net/base/cookie_store.h"
 #include "net/base/net_api.h"
 
 class GURL;
 
 namespace base {
 class Histogram;
@@ skipping 101 matching lines @@
                 Delegate* delegate,
                 int last_access_threshold_milliseconds);
 
   // Parses the string with the cookie time (very forgivingly).
   static base::Time ParseCookieTime(const std::string& time_string);
 
   // Returns true if a domain string represents a host-only cookie,
   // i.e. it doesn't begin with a leading '.' character.
   static bool DomainIsHostOnly(const std::string& domain_string);
 
+  // Helper function that adds all cookies from |cookie_monster| into this
+  // instance.
+  bool InitializeFrom(const CookieList& list);

[erikwright (departed), 2011/08/11 13:58:24]

Who uses this? Must it be public? If nothing else, the comment is incorrect.

[ycxiao, 2011/08/12 02:35:24]

The login_uitls.cc create this function. The previous version of this method
take a cookie_monster as a parameter, and initialize this form the passing
cookie monster. Since I want keep this method synchronous, I change the
signature to
the CookieList.

+
+  typedef base::Callback<void(const CookieList& cookies)> GetCookieListCallback;
+  typedef base::Callback<void(int num_deleted)> DeleteCallback;
+  typedef SetCookiesCallback DeleteCookieCallback;
+
   // Sets a cookie given explicit user-provided cookie attributes. The cookie
   // name, value, domain, etc. are each provided as separate strings. This
   // function expects each attribute to be well-formed. It will check for
   // disallowed characters (e.g. the ';' character is disallowed within the
   // cookie value attribute) and will return false without setting the cookie
   // if such characters are found.
-  bool SetCookieWithDetails(const GURL& url,
-                            const std::string& name,
-                            const std::string& value,
-                            const std::string& domain,
-                            const std::string& path,
-                            const base::Time& expiration_time,
-                            bool secure, bool http_only);
   void SetCookieWithDetailsAsync(const GURL& url,
                                  const std::string& name,
                                  const std::string& value,
                                  const std::string& domain,
                                  const std::string& path,
                                  const base::Time& expiration_time,
                                  bool secure, bool http_only,
                                  const SetCookiesCallback& callback);
 
-
-  // Helper function that adds all cookies from |cookie_monster| into this
-  // instance.
-  bool InitializeFrom(CookieMonster* cookie_monster);
-
   // Returns all the cookies, for use in management UI, etc. This does not mark
   // the cookies as having been accessed.
   // The returned cookies are ordered by longest path, then by earliest
   // creation date.
-  CookieList GetAllCookies();
-  typedef base::Callback<void(const CookieList& cookies)> GetCookieListCallback;
   void GetAllCookiesAsync(const GetCookieListCallback& callback);
 
   // Returns all the cookies, for use in management UI, etc. Filters results
   // using given url scheme, host / domain and path and options. This does not
   // mark the cookies as having been accessed.
   // The returned cookies are ordered by longest path, then earliest
   // creation date.
-  CookieList GetAllCookiesForURLWithOptions(const GURL& url,
-                                            const CookieOptions& options);
   void GetAllCookiesForURLWithOptionsAsync(
       const GURL& url,
       const CookieOptions& options,
       const GetCookieListCallback& callback);
 
   // Invokes GetAllCookiesForURLWithOptions with options set to include HTTP
   // only cookies.
-  CookieList GetAllCookiesForURL(const GURL& url);
   void GetAllCookiesForURLAsync(const GURL& url,
                                 const GetCookieListCallback& callback);
 
   // Deletes all of the cookies.
-  int DeleteAll(bool sync_to_store);
+  void DeleteAllAsync(bool sync_to_store,
+                                     const DeleteCallback& callback);
+
   // Deletes all of the cookies that have a creation_date greater than or equal
   // to |delete_begin| and less than |delete_end|
   // Returns the number of cookies that have been deleted.
-  int DeleteAllCreatedBetween(const base::Time& delete_begin,
-                              const base::Time& delete_end,
-                              bool sync_to_store);
-  typedef base::Callback<void(int num_deleted)> DeleteCallback;
   void DeleteAllCreatedBetweenAsync(const base::Time& delete_begin,
                                     const base::Time& delete_end,
                                     bool sync_to_store,
                                     const DeleteCallback& callback);
 
   // Deletes all cookies that match the host of the given URL
   // regardless of path.  This includes all http_only and secure cookies,
   // but does not include any domain cookies that may apply to this host.
   // Returns the number of cookies deleted.
-  int DeleteAllForHost(const GURL& url);
-
   void DeleteAllForHostAsync(const GURL& url,
                              const DeleteCallback& callback);
 
   // Deletes one specific cookie.
-  bool DeleteCanonicalCookie(const CanonicalCookie& cookie);
-
-  typedef SetCookiesCallback DeleteCookieCallback;
-
   void DeleteCanonicalCookieAsync(const CanonicalCookie& cookie,
                                   const DeleteCookieCallback& callback);
 
   // Override the default list of schemes that are allowed to be set in
   // this cookie store.  Calling his overrides the value of
   // "enable_file_scheme_".
   // If this this method is called, it must be called before first use of
   // the instance (i.e. as part of the instance initialization process).
   void SetCookieableSchemes(const char* schemes[], size_t num_schemes);
 
@@ skipping 21 matching lines @@
   // WARNING: THE CALLBACK WILL RUN ON A RANDOM THREAD. IT MUST BE THREAD SAFE.
   // It may be posted to the current thread, or it may run on the thread that
   // actually does the flushing. Your Task should generally post a notification
   // to the thread you actually want to be notified on.
   void FlushStore(Task* completion_task);
 
   // CookieStore implementation.
 
   // Sets the cookies specified by |cookie_list| returned from |url|
   // with options |options| in effect.
-  virtual bool SetCookieWithOptions(const GURL& url,
-                                    const std::string& cookie_line,
-                                    const CookieOptions& options);
-
   virtual void SetCookieWithOptionsAsync(const GURL& url,

[erikwright (departed), 2011/08/11 13:58:24]

Add OVERRIDE as appropriate.

[ycxiao, 2011/08/12 02:35:24]

Done.

                                          const std::string& cookie_line,
                                          const CookieOptions& options,
                                          const SetCookiesCallback& callback);
 
   // Gets all cookies that apply to |url| given |options|.
   // The returned cookies are ordered by longest path, then earliest
   // creation date.
-  virtual std::string GetCookiesWithOptions(const GURL& url,
-                                            const CookieOptions& options);
-
   virtual void GetCookiesWithOptionsAsync(
       const GURL& url,
       const CookieOptions& options,
       const GetCookiesCallback& callback);
 
-  virtual void GetCookiesWithInfo(const GURL& url,
-                                  const CookieOptions& options,
-                                  std::string* cookie_line,
-                                  std::vector<CookieInfo>* cookie_infos);
-
   virtual void GetCookiesWithInfoAsync(const GURL& url,
                                        const CookieOptions& options,
                                        const GetCookieInfoCallback& callback);
 
   // Deletes all cookies with that might apply to |url| that has |cookie_name|.
-  virtual void DeleteCookie(const GURL& url, const std::string& cookie_name);
   virtual void DeleteCookieAsync(
       const GURL& url, const std::string& cookie_name,
       const base::Closure& callback);
 
   virtual CookieMonster* GetCookieMonster();
 
   // Debugging method to perform various validation checks on the map.
   // Currently just checking that there are no null CanonicalCookie pointers
   // in the map.
   // Argument |arg| is to allow retaining of arbitrary data if the CHECKs
   // in the function trip.  TODO(rdsmith):Remove hack.
   void ValidateMap(int arg);
 
+  // Reads the existing cookies loaded form the backing store.
+  void OnLoaded(const std::vector<CanonicalCookie*>& cookies);

[erikwright (departed), 2011/08/11 13:58:24]

Why is this not private?

[ycxiao, 2011/08/12 02:35:24]

You are right, it should be.

+
   // The default list of schemes the cookie monster can handle.
   static const char* kDefaultCookieableSchemes[];
   static const int kDefaultCookieableSchemesCount;
 
  private:
   // Testing support.
   // For SetCookieWithCreationTime.
   FRIEND_TEST_ALL_PREFIXES(CookieMonsterTest,
                            TestCookieDeleteAllCreatedBetweenTimestamps);
 
@@ skipping 73 matching lines @@
 
   // Default value for key and expiry scheme scheme.
   static const ExpiryAndKeyScheme expiry_and_key_default_ =
       EKS_KEEP_RECENT_AND_PURGE_ETLDP1;
 
   // Record statistics every kRecordStatisticsIntervalSeconds of uptime.
   static const int kRecordStatisticsIntervalSeconds = 10 * 60;
 
   virtual ~CookieMonster();
 
+  bool SetCookieWithDetails(const GURL& url,
+                            const std::string& name,
+                            const std::string& value,
+                            const std::string& domain,
+                            const std::string& path,
+                            const base::Time& expiration_time,
+                            bool secure, bool http_only);
+
+  CookieList GetAllCookies();
+
+  CookieList GetAllCookiesForURLWithOptions(const GURL& url,
+                                            const CookieOptions& options);
+
+  CookieList GetAllCookiesForURL(const GURL& url);
+
+  int DeleteAll(bool sync_to_store);
+
+  int DeleteAllCreatedBetween(const base::Time& delete_begin,
+                              const base::Time& delete_end,
+                              bool sync_to_store);
+
+  int DeleteAllForHost(const GURL& url);
+
+  bool DeleteCanonicalCookie(const CanonicalCookie& cookie);
+
+  bool SetCookieWithOptions(const GURL& url,
+                            const std::string& cookie_line,
+                            const CookieOptions& options);
+
+  std::string GetCookiesWithOptions(const GURL& url,
+                                    const CookieOptions& options);
+
+  void GetCookiesWithInfo(const GURL& url,
+                          const CookieOptions& options,
+                          std::string* cookie_line,
+                          std::vector<CookieInfo>* cookie_infos);
+
+  void DeleteCookie(const GURL& url, const std::string& cookie_name);
+
   bool SetCookieWithCreationTime(const GURL& url,
                                  const std::string& cookie_line,
                                  const base::Time& creation_time);
 
   // Called by all non-static functions to ensure that the cookies store has
   // been initialized. This is not done during creating so it doesn't block
   // the window showing.
   // Note: this method should always be called with lock_ held.
   void InitIfNecessary() {
     if (!initialized_) {
-      if (store_)
+      if (store_) {
         InitStore();
+      } else {
+        loaded_ = true;
+      }
       initialized_ = true;
     }
   }
 
   // Initializes the backing store and reads existing cookies from it.
   // Should only be called by InitIfNecessary().
   void InitStore();
 
+  // Invoke the queueing calls of CookieMonster when loading cookies from
+  // the back store is complete.
+  void InvokeQueue();
+
   // Checks that |cookies_| matches our invariants, and tries to repair any
   // inconsistencies. (In other words, it does not have duplicate cookies).
   void EnsureCookiesMapIsValid();
 
   // Checks for any duplicate cookies for CookieMap key |key| which lie between
   // |begin| and |end|. If any are found, all but the most recent are deleted.
   // Returns the number of duplicate cookies that were deleted.
   int TrimDuplicateCookiesForKey(const std::string& key,
                                  CookieMap::iterator begin,
                                  CookieMap::iterator end);
@@ skipping 89 matching lines @@
   void RecordPeriodicStats(const base::Time& current_time);
 
   // Initialize the above variables; should only be called from
   // the constructor.
   void InitializeHistograms();
 
   // The resolution of our time isn't enough, so we do something
   // ugly and increment when we've seen the same time twice.
   base::Time CurrentTime();
 
+  // Store the parameters of cookie monster API.
+  class CookieAPIParameters {

[erikwright (departed), 2011/08/11 13:58:24]

In cookie_monster.cc, define a class named CookieMonsterTask.

Define subclasses such as

class GetCookiesWithOptionsTask : public CookieMonsterTask {
public:
  GetCookiesWithOptionsTask(CookieMonster* cookie_monster,
                            const GURL& url,
                            const CookieOptions& options,
                            const GetCookiesCallback& callback)
    : CookieMonsterTask(cookie_monster),
      url_(url),
      options_(options),
      callback_(callback) {}

  virtual void Run() OVERRIDE {
    std::string cookies =
        this->cookie_monster()->GetCookiesWithOptions(url_, options_);
    // InvokeCallback takes a closure and runs it on the thread from which the
    // CookieMonsterTask was originally constructed.
    this->InvokeCallback(
        base::Bind(&GetCookiesCallback::Run, &callback, cookies));
  }
};

The subclasses must be friends of CookieMonster.

You can create closures from CookieMonsterTask::Run and a subclass instance and
store those in your queue.

[ycxiao, 2011/08/12 02:35:24]

Done.

+   public:
+    CookieAPIParameters()
+        : secure(false),
+          http_only(false),
+          sync_to_store(false) { }
+
+    GURL* url;
+    CookieOptions options;
+    std::string name;
+    std::string value;
+    std::string domain;
+    std::string path;
+    std::string cookie_line;
+    bool secure;
+    bool http_only;
+    bool sync_to_store;
+    base::Time delete_begin;
+    base::Time delete_end;
+    base::Time expiration_time;
+    CanonicalCookie* cookie;
+  };
+
+  // Run the cookie request task if cookie loaded, otherwise added the task
+  // to task queue.
+  void DoCookieTask(const base::Closure& task);

[erikwright (departed), 2011/08/11 13:58:24]

All of these task methods go away and become classes defined in the .cc file.

[ycxiao, 2011/08/12 02:35:24]

Done.

+
+  // Task functions for queueing the coming request.
+
+  void SetCookieWithDetailsTask(
+      const SetCookiesCallback& callback,
+      const CookieAPIParameters& para,
+      scoped_refptr<base::MessageLoopProxy> thread);
+
+  void GetAllCookiesTask(
+      const GetCookieListCallback& callback,
+      scoped_refptr<base::MessageLoopProxy> thread);
+
+  void GetAllCookiesForURLWithOptionsTask(
+      const GetCookieListCallback& callback,
+      const CookieAPIParameters& para,
+      scoped_refptr<base::MessageLoopProxy> thread);
+
+  void GetAllCookiesForURLTask(
+      const GetCookieListCallback& callback,
+      const CookieAPIParameters& para,
+      scoped_refptr<base::MessageLoopProxy> thread);
+
+  void DeleteAllTask(
+      const DeleteCallback& callback,
+      const CookieAPIParameters& para,
+      scoped_refptr<base::MessageLoopProxy> thread);
+
+  void DeleteAllCreatedBetweenTask(
+      const DeleteCallback& callback,
+      const CookieAPIParameters& para,
+      scoped_refptr<base::MessageLoopProxy> thread);
+
+  void DeleteAllForHostTask(
+      const DeleteCallback& callback,
+      const CookieAPIParameters& para,
+      scoped_refptr<base::MessageLoopProxy> thread);
+
+  void DeleteCanonicalCookieTask(
+      const DeleteCookieCallback& callback,
+      const CookieAPIParameters& para,
+      scoped_refptr<base::MessageLoopProxy> thread);
+
+  void SetCookieWithOptionsTask(
+      const SetCookiesCallback& callback,
+      const CookieAPIParameters& para,
+      scoped_refptr<base::MessageLoopProxy> thread);
+
+  void GetCookiesWithOptionsTask(
+      const GetCookiesCallback& callback,
+      const CookieAPIParameters& para,
+      scoped_refptr<base::MessageLoopProxy> thread);
+
+  void GetCookiesWithInfoTask(
+      const GetCookieInfoCallback& callback,
+      const CookieAPIParameters& para,
+      scoped_refptr<base::MessageLoopProxy> thread);
+
+  void DeleteCookieTask(
+      const base::Closure& callback,
+      const CookieAPIParameters& para,
+      scoped_refptr<base::MessageLoopProxy> thread);
+
   // Histogram variables; see CookieMonster::InitializeHistograms() in
   // cookie_monster.cc for details.
   base::Histogram* histogram_expiration_duration_minutes_;
   base::Histogram* histogram_between_access_interval_minutes_;
   base::Histogram* histogram_evicted_last_access_minutes_;
   base::Histogram* histogram_count_;
   base::Histogram* histogram_domain_count_;
   base::Histogram* histogram_etldp1_count_;
   base::Histogram* histogram_domain_per_etldp1_count_;
   base::Histogram* histogram_number_duplicate_db_cookies_;
   base::Histogram* histogram_cookie_deletion_cause_;
   base::Histogram* histogram_time_get_;
   base::Histogram* histogram_time_mac_;
   base::Histogram* histogram_time_load_;
 
   CookieMap cookies_;
 
   // Indicates whether the cookie store has been initialized. This happens
   // lazily in InitStoreIfNecessary().
   bool initialized_;
 
+  // Indicate whether the cookies are loaded from disk.

[erikwright (departed), 2011/08/11 13:58:24]

"Indicates whether loading from the backend store is completed and calls may be
immediately processed."

[ycxiao, 2011/08/12 02:35:24]

Done.

+  bool loaded_;
+
+  // Queue the calls of CookieMonster while the loadind form the back

[erikwright (departed), 2011/08/11 13:58:24]

"Queues calls to CookieMonster until loading from the backend store is
completed."

[ycxiao, 2011/08/12 02:35:24]

Done.

+  // store haven't complete.
+  std::deque<base::Closure> queue_;

[erikwright (departed), 2011/08/11 13:58:24]

Can you define this as std::queue<base::Closure> instead? It uses a deque
internally but is slightly clearer about the intended use.

[ycxiao, 2011/08/12 02:35:24]

Done.

+
   // Indicates whether this cookie monster uses the new effective domain
   // key scheme or not.
   ExpiryAndKeyScheme expiry_and_key_scheme_;
 
   scoped_refptr<PersistentCookieStore> store_;
 
   base::Time last_time_seen_;
 
   // Minimum delay after updating a cookie's LastAccessDate before we will
   // update it again.
@@ skipping 50 matching lines @@
 
   // This constructor does canonicalization but not validation.
   // The result of this constructor should not be relied on in contexts
   // in which pre-validation of the ParsedCookie has not been done.
   CanonicalCookie(const GURL& url, const ParsedCookie& pc);
 
   ~CanonicalCookie();
 
   // Supports the default copy constructor.
 
+  // Creates a canonical cookie from parsed cookie.
+  // Canonicalizes and validates inputs.  May return NULL if an attribute
+  // value is invalid.
+  static CanonicalCookie* Create(const GURL& url,
+                                 const ParsedCookie& pc);
+
   // Creates a canonical cookie from unparsed attribute values.
   // Canonicalizes and validates inputs.  May return NULL if an attribute
   // value is invalid.
   static CanonicalCookie* Create(const GURL& url,
                                  const std::string& name,
                                  const std::string& value,
                                  const std::string& domain,
                                  const std::string& path,
                                  const std::string& mac_key,
                                  const std::string& mac_algorithm,
@@ skipping 218 matching lines @@
 };
 
 typedef base::RefCountedThreadSafe<CookieMonster::PersistentCookieStore>
     RefcountedPersistentCookieStore;
 
 class CookieMonster::PersistentCookieStore
     : public RefcountedPersistentCookieStore {
  public:
   virtual ~PersistentCookieStore() {}
 
+  typedef base::Callback<void(const std::vector<
+      CookieMonster::CanonicalCookie*>&)> LoadedCallback;
+
   // Initializes the store and retrieves the existing cookies. This will be
   // called only once at startup.
-  virtual bool Load(std::vector<CookieMonster::CanonicalCookie*>* cookies) = 0;
+  virtual bool Load(const LoadedCallback& loaded_callback) = 0;
 
   virtual void AddCookie(const CanonicalCookie& cc) = 0;
   virtual void UpdateCookieAccessTime(const CanonicalCookie& cc) = 0;
   virtual void DeleteCookie(const CanonicalCookie& cc) = 0;
 
   // Sets the value of the user preference whether the persistent storage
   // must be deleted upon destruction.
   virtual void SetClearLocalStateOnExit(bool clear_local_state) = 0;
 
   // Flush the store and post the given Task when complete.
   virtual void Flush(Task* completion_task) = 0;
 
  protected:
   PersistentCookieStore() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PersistentCookieStore);
 };
 
 class CookieList : public std::vector<CookieMonster::CanonicalCookie> {
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_COOKIE_MONSTER_H_