Update from chromium https://crrev.com/302282

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 289 matching lines @@
     // 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);
+              const CookieStore::CookieChangedCallback& callback,
+              const CanonicalCookie& cookie,
+              bool removed) {
+  proxy->PostTask(FROM_HERE, base::Bind(callback, cookie, removed));
 }
 
 }  // namespace
 
 CookieMonster::CookieMonster(PersistentCookieStore* store,
                              CookieMonsterDelegate* delegate)
     : initialized_(false),
       loaded_(store == NULL),
       store_(store),
       last_access_threshold_(
@@ skipping 1453 matching lines @@
 
   if ((cc->IsPersistent() || persist_session_cookies_) && store_.get() &&
       sync_to_store)
     store_->AddCookie(*cc);
   CookieMap::iterator inserted =
       cookies_.insert(CookieMap::value_type(key, cc));
   if (delegate_.get()) {
     delegate_->OnCookieChanged(
         *cc, false, CookieMonsterDelegate::CHANGE_COOKIE_EXPLICIT);
   }
+  RunCallbacks(*cc, false);
 
   return inserted;
 }
 
 bool CookieMonster::SetCookieWithCreationTimeAndOptions(
     const GURL& url,
     const std::string& cookie_line,
     const Time& creation_time_or_null,
     const CookieOptions& options) {
   lock_.AssertAcquired();
@@ skipping 36 matching lines @@
   if (!already_expired || keep_expired_cookies_) {
     // See InitializeHistograms() for details.
     if ((*cc)->IsPersistent()) {
       histogram_expiration_duration_minutes_->Add(
           ((*cc)->ExpiryDate() - creation_time).InMinutes());
     }
 
     {
       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().
@@ 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);
   }
+  RunCallbacks(*cc, true);
   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 396 matching lines @@
 
 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));
+  return hook_map_[key]->Add(
+      base::Bind(&RunAsync, base::MessageLoopProxy::current(), callback));
 }
 
-void CookieMonster::RunCallbacks(const CanonicalCookie& cookie) {
+void CookieMonster::RunCallbacks(const CanonicalCookie& cookie, bool removed) {
   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();
+      it->second->Notify(cookie, removed);
     }
   }
 }
 
 }  // namespace net