Add AddCallbackForCookie method to CookieStore.

net/cookies/cookie_monster.cc

 // Copyright (c) 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.
 
 // Portions of this code based on Mozilla:
 //   (netwerk/cookie/src/nsCookieService.cpp)
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public License Version
@@ skipping 45 matching lines @@
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/cookies/canonical_cookie.h"
 #include "net/cookies/cookie_util.h"
 #include "net/cookies/parsed_cookie.h"
-#include "url/gurl.h"
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 
 // In steady state, most cookie requests can be satisfied by the in memory
 // cookie monster store.  However, if a request comes in during the initial
 // cookie load, it must be delayed until that load completes. That is done by
 // queueing it on CookieMonster::tasks_pending_ and running it when notification
 // of cookie load completion is received via CookieMonster::OnLoaded. This
@@ skipping 223 matching lines @@
     // In Mozilla if you set a cookie like AAAA, it will have an empty token
     // and a value of AAAA.  When it sends the cookie back, it will send AAAA,
     // so we need to avoid sending =AAAA for a blank token value.
     if (!(*it)->Name().empty())
       cookie_line += (*it)->Name() + "=";
     cookie_line += (*it)->Value();
   }
   return cookie_line;
 }
 
+void RunAsync(scoped_refptr<base::TaskRunner> proxy,
+              const CookieStore::CookieChangedCallback& callback) {
+  proxy->PostTask(FROM_HERE, callback);
+}
+
 }  // namespace
 
 CookieMonster::CookieMonster(PersistentCookieStore* store,
                              CookieMonsterDelegate* delegate)
     : initialized_(false),
       loaded_(store == NULL),
       store_(store),
       last_access_threshold_(
           TimeDelta::FromSeconds(kDefaultAccessUpdateThresholdSeconds)),
       delegate_(delegate),
@@ skipping 576 matching lines @@
     const std::string& path,
     const Time& expiration_time,
     bool secure,
     bool http_only,
     CookiePriority priority,
     const SetCookiesCallback& callback) {
   scoped_refptr<SetCookieWithDetailsTask> task =
       new SetCookieWithDetailsTask(this, url, name, value, domain, path,
                                    expiration_time, secure, http_only, priority,
                                    callback);
-
   DoCookieTaskForURL(task, url);
 }
 
 void CookieMonster::GetAllCookiesAsync(const GetCookieListCallback& callback) {
   scoped_refptr<GetAllCookiesTask> task =
       new GetAllCookiesTask(this, callback);
 
   DoCookieTask(task);
 }
 
@@ skipping 889 matching lines @@
     return false;
   }
   return SetCanonicalCookie(&cc, creation_time, options);
 }
 
 bool CookieMonster::SetCanonicalCookie(scoped_ptr<CanonicalCookie>* cc,
                                        const Time& creation_time,
                                        const CookieOptions& options) {
   const std::string key(GetKey((*cc)->Domain()));
   bool already_expired = (*cc)->IsExpired(creation_time);
+
   if (DeleteAnyEquivalentCookie(key, **cc, options.exclude_httponly(),
                                 already_expired)) {
     VLOG(kVlogSetCookies) << "SetCookie() not clobbering httponly cookie";
     return false;
   }
 
   VLOG(kVlogSetCookies) << "SetCookie() key: " << key << " cc: "
                         << (*cc)->DebugString();
 
   // Realize that we might be setting an expired cookie, and the only point
   // was to delete the cookie which we've already done.
   if (!already_expired || keep_expired_cookies_) {
     // See InitializeHistograms() for details.
     if ((*cc)->IsPersistent()) {
       histogram_expiration_duration_minutes_->Add(
           ((*cc)->ExpiryDate() - creation_time).InMinutes());
     }
 
-    InternalInsertCookie(key, cc->release(), true);
+    {
+      CanonicalCookie cookie = *(cc->get());
+      InternalInsertCookie(key, cc->release(), true);
+      RunCallbacks(cookie);
+    }
   } else {
     VLOG(kVlogSetCookies) << "SetCookie() not storing already expired cookie.";
   }
 
   // We assume that hopefully setting a cookie will be less common than
   // querying a cookie.  Since setting a cookie can put us over our limits,
   // make sure that we garbage collect...  We can also make the assumption that
   // if a cookie was set, in the common case it will be used soon after,
   // and we will purge the expired cookies in GetCookies().
   GarbageCollect(creation_time, key);
@@ skipping 44 matching lines @@
   if ((cc->IsPersistent() || persist_session_cookies_) && store_.get() &&
       sync_to_store)
     store_->DeleteCookie(*cc);
   if (delegate_.get()) {
     ChangeCausePair mapping = ChangeCauseMapping[deletion_cause];
 
     if (mapping.notify)
       delegate_->OnCookieChanged(*cc, true, mapping.cause);
   }
   cookies_.erase(it);
+  RunCallbacks(*cc);
   delete cc;
 }
 
 // Domain expiry behavior is unchanged by key/expiry scheme (the
 // meaning of the key is different, but that's not visible to this routine).
 int CookieMonster::GarbageCollect(const Time& current,
                                   const std::string& key) {
   lock_.AssertAcquired();
 
   int num_deleted = 0;
@@ skipping 387 matching lines @@
   }
 
   return true;
 }
 
 bool CookieMonster::loaded() {
   base::AutoLock autolock(lock_);
   return loaded_;
 }
 
+scoped_ptr<CookieStore::CookieChangedSubscription>
+CookieMonster::AddCallbackForCookie(
+    const GURL& gurl,
+    const std::string& name,
+    const CookieChangedCallback& callback) {
+  base::AutoLock autolock(lock_);
+  std::pair<GURL, std::string> key(gurl, name);
+  if (hook_map_.count(key) == 0)
+    hook_map_[key] = make_linked_ptr(new CookieChangedCallbackList());
+  return hook_map_[key]->Add(base::Bind(
+      &RunAsync, base::MessageLoopProxy::current(), callback));
+}
+
+void CookieMonster::RunCallbacks(const CanonicalCookie& cookie) {
+  lock_.AssertAcquired();
+  CookieOptions opts;
+  opts.set_include_httponly();
+  // Note that the callbacks in hook_map_ are wrapped with MakeAsync(), so they
+  // are guaranteed to not take long - they just post a RunAsync task back to
+  // the appropriate thread's message loop and return. It is important that this
+  // method not run user-supplied callbacks directly, since the CookieMonster
+  // lock is held and it is easy to accidentally introduce deadlocks.
+  for (CookieChangedHookMap::iterator it = hook_map_.begin();
+       it != hook_map_.end(); ++it) {
+    std::pair<GURL, std::string> key = it->first;
+    if (cookie.IncludeForRequestURL(key.first, opts) &&
+        cookie.Name() == key.second) {
+      it->second->Notify();
+    }
+  }
+}
+
 }  // namespace net