Injecting an NSHTTPCookieStorage dependency into CookieStoreIOS

ios/net/cookies/cookie_store_ios.h

 // Copyright 2012 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 IOS_NET_COOKIES_COOKIE_STORE_IOS_H_
 #define IOS_NET_COOKIES_COOKIE_STORE_IOS_H_
 
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/cancelable_callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "ios/net/cookies/cookie_cache.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/cookies/cookie_store.h"
 #include "url/gurl.h"
 
 #if defined(__OBJC__)
 @class NSHTTPCookie;
+@class NSHTTPCookieStorage;
 @class NSArray;
 #else
 class NSHTTPCookie;
+class NSHTTPCookieStorage;
 class NSArray;
 #endif
 
 namespace net {
 
 class CookieCreationTimeManager;
 
-// Observer for system cookie notifications.
+// Observer for changes on |NSHTTPCookieStorge sharedHTTPCookieStorage|.
 class CookieNotificationObserver {
  public:
-  // Called when any cookie is added, deleted or changed in the system store.
+  // Called when any cookie is added, deleted or changed in
+  // |NSHTTPCookieStorge sharedHTTPCookieStorage|.
   virtual void OnSystemCookiesChanged() = 0;
-  // Called when the cookie policy changes.
+  // Called when the cookie policy changes on
+  // |NSHTTPCookieStorge sharedHTTPCookieStorage|.
   virtual void OnSystemCookiePolicyChanged() = 0;
 };
 
 // The CookieStoreIOS is an implementation of CookieStore relying on
 // NSHTTPCookieStorage, ensuring that the cookies are consistent between the
 // network stack and the UIWebViews.
 // On iOS, the Chrome CookieMonster is not used in conjunction with UIWebView,
 // because UIWebView expects the cookies to be in the shared
 // NSHTTPCookieStorage. In particular, javascript may read and write cookies
 // there.
 // CookieStoreIOS is not thread safe.
 //
 // At any given time, a CookieStoreIOS can either be synchronized with the
 // system cookie store or not. If a CookieStoreIOS is not synchronized with the
 // system store, changes are written back to the backing CookieStore. If a
 // CookieStoreIOS is synchronized with the system store, changes are written
 // directly to the system cookie store, then propagated to the backing store by
 // OnSystemCookiesChanged, which is called by the system store once the change
 // to the system store is written back.
 //
 // To unsynchronize, CookieStoreIOS copies the system cookie store into its
 // backing CookieStore. To synchronize, CookieStoreIOS clears the system cookie
 // store, copies its backing CookieStore into the system cookie store.
 class CookieStoreIOS : public net::CookieStore,
                        public CookieNotificationObserver {
  public:
+  // Creates a CookieStoreIOS with a default value of
+  // |NSHTTPCookieStorage sharedCookieStorage| as the system's cookie store.
   explicit CookieStoreIOS(
       net::CookieMonster::PersistentCookieStore* persistent_store);
 
+  explicit CookieStoreIOS(
+      net::CookieMonster::PersistentCookieStore* persistent_store,
+      NSHTTPCookieStorage* system_store);
+
   enum CookiePolicy { ALLOW, BLOCK };
 
   // Must be called on the thread where CookieStoreIOS instances live.
+  // Affects only those CookieStoreIOS instances that are backed by
+  // |NSHTTPCookieStorage sharedHTTPCookieStorage|.
   static void SetCookiePolicy(CookiePolicy setting);
 
   // Create an instance of CookieStoreIOS that is generated from the cookies
-  // stored in the system NSHTTPCookieStorage. The caller is responsible for
-  // deleting the cookie store.
-  // Apple does not persist the cookies' creation dates in the system store,
+  // stored in |cookie_storage|. The CookieStoreIOS uses the |cookie_storage|
+  // as its default backend.

[droger, 2015/11/03 10:24:07]

Nit: While you are touching this, can you add something like:
"and is initially synchronized with it"

[shreyasv1, 2015/11/03 18:15:46]

Done.

+  // Apple does not persist the cookies' creation dates in NSHTTPCookieStorage,
   // so callers should not expect these values to be populated.
-  static CookieStoreIOS* CreateCookieStoreFromNSHTTPCookieStorage();
+  static CookieStoreIOS* CreateCookieStore(NSHTTPCookieStorage* cookie_storage);
 
   // As there is only one system store, only one CookieStoreIOS at a time may
   // be synchronized with it.
   static void SwitchSynchronizedStore(CookieStoreIOS* old_store,
                                       CookieStoreIOS* new_store);
 
-  // Must be called when the state of the system cookie store changes.
+  // Must be called when the state of
+  // |NSHTTPCookieStorage sharedHTTPCookieStorage| changes.
+  // Affects only those CookieStoreIOS instances that are backed by
+  // |NSHTTPCookieStorage sharedHTTPCookieStorage|.
   static void NotifySystemCookiesChanged();
 
   // Saves the cookies to the cookie monster.
   // Note: ignores the write cookie operation if |write_on_flush_| is false.
   void Flush(const base::Closure& callback);
 
   // Unsynchronizes the cookie store if it is currently synchronized.
   void UnSynchronize();
 
   // Only one cookie store may enable metrics.
@@ skipping 70 matching lines @@
   void RunAllPendingTasks();
 
   // Inherited CookieNotificationObserver methods.
   void OnSystemCookiesChanged() override;
   void OnSystemCookiePolicyChanged() override;
 
   void DeleteCookiesWithFilter(const CookieFilterFunction& filter,
                                const DeleteCallback& callback);
 
   scoped_refptr<net::CookieMonster> cookie_monster_;
+  NSHTTPCookieStorage* system_store_;
   scoped_ptr<CookieCreationTimeManager> creation_time_manager_;
   bool metrics_enabled_;
   base::TimeDelta flush_delay_;
   base::CancelableClosure flush_closure_;
 
   SynchronizationState synchronization_state_;
   // Tasks received when SYNCHRONIZING are queued and run when SYNCHRONIZED.
   std::vector<base::Closure> tasks_pending_synchronization_;
 
   base::ThreadChecker thread_checker_;
@@ skipping 103 matching lines @@
   typedef std::map<std::pair<GURL, std::string>, CookieChangedCallbackList*>
       CookieChangedHookMap;
   CookieChangedHookMap hook_map_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieStoreIOS);
 };
 
 }  // namespace net
 
 #endif  // IOS_NET_COOKIES_COOKIE_STORE_IOS_H_