Home | History | Annotate | Download | only in cookies 
      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 // This file contains test infrastructure for multiple files
      6 // (current cookie_monster_unittest.cc and cookie_monster_perftest.cc)
      7 // that need to test out CookieMonster interactions with the backing store.
      8 // It should only be included by test code.
      9 
     10 #ifndef NET_COOKIES_COOKIE_MONSTER_STORE_TEST_H_
     11 #define NET_COOKIES_COOKIE_MONSTER_STORE_TEST_H_
     12 
     13 #include <map>
     14 #include <string>
     15 #include <utility>
     16 #include <vector>
     17 #include "net/cookies/canonical_cookie.h"
     18 #include "net/cookies/cookie_monster.h"
     19 
     20 namespace base {
     21 class Time;
     22 }
     23 
     24 namespace net {
     25 
     26 // Wrapper class for posting a loaded callback. Since the Callback class is not
     27 // reference counted, we cannot post a callback to the message loop directly,
     28 // instead we post a LoadedCallbackTask.
     29 class LoadedCallbackTask
     30     : public base::RefCountedThreadSafe<LoadedCallbackTask> {
     31  public:
     32   typedef CookieMonster::PersistentCookieStore::LoadedCallback LoadedCallback;
     33 
     34   LoadedCallbackTask(LoadedCallback loaded_callback,
     35                      std::vector<CanonicalCookie*> cookies);
     36 
     37   void Run() {
     38     loaded_callback_.Run(cookies_);
     39   }
     40 
     41  private:
     42   friend class base::RefCountedThreadSafe<LoadedCallbackTask>;
     43   ~LoadedCallbackTask();
     44 
     45   LoadedCallback loaded_callback_;
     46   std::vector<CanonicalCookie*> cookies_;
     47 
     48   DISALLOW_COPY_AND_ASSIGN(LoadedCallbackTask);
     49 };  // Wrapper class LoadedCallbackTask
     50 
     51 // Describes a call to one of the 3 functions of PersistentCookieStore.
     52 struct CookieStoreCommand {
     53   enum Type {
     54     ADD,
     55     UPDATE_ACCESS_TIME,
     56     REMOVE,
     57   };
     58 
     59   CookieStoreCommand(Type type, const CanonicalCookie& cookie)
     60       : type(type),
     61         cookie(cookie) {}
     62 
     63   Type type;
     64   CanonicalCookie cookie;
     65 };
     66 
     67 // Implementation of PersistentCookieStore that captures the
     68 // received commands and saves them to a list.
     69 // The result of calls to Load() can be configured using SetLoadExpectation().
     70 class MockPersistentCookieStore
     71     : public CookieMonster::PersistentCookieStore {
     72  public:
     73   typedef std::vector<CookieStoreCommand> CommandList;
     74 
     75   MockPersistentCookieStore();
     76 
     77   void SetLoadExpectation(
     78       bool return_value,
     79       const std::vector<CanonicalCookie*>& result);
     80 
     81   const CommandList& commands() const {
     82     return commands_;
     83   }
     84 
     85   virtual void Load(const LoadedCallback& loaded_callback) OVERRIDE;
     86 
     87   virtual void LoadCookiesForKey(const std::string& key,
     88     const LoadedCallback& loaded_callback) OVERRIDE;
     89 
     90   virtual void AddCookie(const CanonicalCookie& cookie) OVERRIDE;
     91 
     92   virtual void UpdateCookieAccessTime(
     93       const CanonicalCookie& cookie) OVERRIDE;
     94 
     95   virtual void DeleteCookie(
     96       const CanonicalCookie& cookie) OVERRIDE;
     97 
     98   virtual void Flush(const base::Closure& callback) OVERRIDE;
     99 
    100   virtual void SetForceKeepSessionState() OVERRIDE;
    101 
    102  protected:
    103   virtual ~MockPersistentCookieStore();
    104 
    105  private:
    106   CommandList commands_;
    107 
    108   // Deferred result to use when Load() is called.
    109   bool load_return_value_;
    110   std::vector<CanonicalCookie*> load_result_;
    111   // Indicates if the store has been fully loaded to avoid returning duplicate
    112   // cookies.
    113   bool loaded_;
    114 
    115   DISALLOW_COPY_AND_ASSIGN(MockPersistentCookieStore);
    116 };
    117 
    118 // Mock for CookieMonsterDelegate
    119 class MockCookieMonsterDelegate : public CookieMonsterDelegate {
    120  public:
    121   typedef std::pair<CanonicalCookie, bool>
    122       CookieNotification;
    123 
    124   MockCookieMonsterDelegate();
    125 
    126   const std::vector<CookieNotification>& changes() const { return changes_; }
    127 
    128   void reset() { changes_.clear(); }
    129 
    130   virtual void OnCookieChanged(
    131       const CanonicalCookie& cookie,
    132       bool removed,
    133       CookieMonsterDelegate::ChangeCause cause) OVERRIDE;
    134 
    135   virtual void OnLoaded() OVERRIDE;
    136 
    137  private:
    138   virtual ~MockCookieMonsterDelegate();
    139 
    140   std::vector<CookieNotification> changes_;
    141 
    142   DISALLOW_COPY_AND_ASSIGN(MockCookieMonsterDelegate);
    143 };
    144 
    145 // Helper to build a single CanonicalCookie.
    146 CanonicalCookie BuildCanonicalCookie(const std::string& key,
    147                                      const std::string& cookie_line,
    148                                      const base::Time& creation_time);
    149 
    150 // Helper to build a list of CanonicalCookie*s.
    151 void AddCookieToList(
    152     const std::string& key,
    153     const std::string& cookie_line,
    154     const base::Time& creation_time,
    155     std::vector<CanonicalCookie*>* out_list);
    156 
    157 // Just act like a backing database.  Keep cookie information from
    158 // Add/Update/Delete and regurgitate it when Load is called.
    159 class MockSimplePersistentCookieStore
    160     : public CookieMonster::PersistentCookieStore {
    161  public:
    162   MockSimplePersistentCookieStore();
    163 
    164   virtual void Load(const LoadedCallback& loaded_callback) OVERRIDE;
    165 
    166   virtual void LoadCookiesForKey(const std::string& key,
    167       const LoadedCallback& loaded_callback) OVERRIDE;
    168 
    169   virtual void AddCookie(const CanonicalCookie& cookie) OVERRIDE;
    170 
    171   virtual void UpdateCookieAccessTime(const CanonicalCookie& cookie) OVERRIDE;
    172 
    173   virtual void DeleteCookie(const CanonicalCookie& cookie) OVERRIDE;
    174 
    175   virtual void Flush(const base::Closure& callback) OVERRIDE;
    176 
    177   virtual void SetForceKeepSessionState() OVERRIDE;
    178 
    179  protected:
    180   virtual ~MockSimplePersistentCookieStore();
    181 
    182  private:
    183   typedef std::map<int64, CanonicalCookie> CanonicalCookieMap;
    184 
    185   CanonicalCookieMap cookies_;
    186 
    187   // Indicates if the store has been fully loaded to avoid return duplicate
    188   // cookies in subsequent load requests
    189   bool loaded_;
    190 };
    191 
    192 // Helper function for creating a CookieMonster backed by a
    193 // MockSimplePersistentCookieStore for garbage collection testing.
    194 //
    195 // Fill the store through import with |num_cookies| cookies, |num_old_cookies|
    196 // with access time Now()-days_old, the rest with access time Now().
    197 // Do two SetCookies().  Return whether each of the two SetCookies() took
    198 // longer than |gc_perf_micros| to complete, and how many cookie were
    199 // left in the store afterwards.
    200 CookieMonster* CreateMonsterFromStoreForGC(
    201     int num_cookies,
    202     int num_old_cookies,
    203     int days_old);
    204 
    205 }  // namespace net
    206 
    207 #endif  // NET_COOKIES_COOKIE_MONSTER_STORE_TEST_H_
    208