Promote CookieMonster::DeleteCanonicalCookieAsync to CookieStore.

chrome/browser/sessions/session_data_deleter.cc

 // Copyright 2013 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.
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/prefs/session_startup_pref.h"
 #include "chrome/browser/profiles/profile_io_data.h"
 #include "chrome/browser/ui/startup/startup_browser_creator.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/dom_storage_context.h"
 #include "content/public/browser/local_storage_usage_info.h"
 #include "content/public/browser/storage_partition.h"
-#include "net/cookies/cookie_monster.h"
 #include "net/cookies/cookie_store.h"
 #include "net/cookies/cookie_util.h"
 #include "net/url_request/url_request_context.h"
 #include "storage/browser/quota/special_storage_policy.h"
 
 namespace {
 
-void CookieDeleted(bool success) {
-  DCHECK(success);
+void CookieDeleted(int num_cookies_deleted) {
+  DCHECK_EQ(1, num_cookies_deleted);
 }
 
 class SessionDataDeleter
     : public base::RefCountedThreadSafe<SessionDataDeleter> {
  public:
   SessionDataDeleter(storage::SpecialStoragePolicy* storage_policy,
                      bool delete_only_by_session_only_policy);
 
   void Run(content::StoragePartition* storage_partition,
            ProfileIOData* profile_io_data);
@@ skipping 14 matching lines @@
   // of all remaining cookies.
   void DeleteSessionCookiesOnIOThread(ProfileIOData* profile_io_data);
 
   // Called when all session-only cookies have been deleted.
   void DeleteSessionCookiesDone(int num_deleted);
 
   // Deletes the cookies in |cookies| that are for origins which are
   // session-only.
   void DeleteSessionOnlyOriginCookies(const net::CookieList& cookies);
 
-  scoped_refptr<net::CookieMonster> cookie_monster_;
+  scoped_refptr<net::CookieStore> cookie_store_;
   scoped_refptr<storage::SpecialStoragePolicy> storage_policy_;
   const bool delete_only_by_session_only_policy_;
 
   DISALLOW_COPY_AND_ASSIGN(SessionDataDeleter);
 };
 
 SessionDataDeleter::SessionDataDeleter(
     storage::SpecialStoragePolicy* storage_policy,
     bool delete_only_by_session_only_policy)
     : storage_policy_(storage_policy),
@@ skipping 29 matching lines @@
       continue;
     storage_partition->GetDOMStorageContext()->DeleteLocalStorage(usage.origin);
   }
 }
 
 void SessionDataDeleter::DeleteSessionCookiesOnIOThread(
     ProfileIOData* profile_io_data) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   net::URLRequestContext* request_context =
       profile_io_data->GetMainRequestContext();
-  cookie_monster_ = request_context->cookie_store()->GetCookieMonster();
+  cookie_store_ = request_context->cookie_store();
   if (delete_only_by_session_only_policy_) {
-    cookie_monster_->GetAllCookiesAsync(
+    cookie_store_->GetAllCookiesAsync(
         base::Bind(&SessionDataDeleter::DeleteSessionOnlyOriginCookies, this));
   } else {
-    cookie_monster_->DeleteSessionCookiesAsync(
+    cookie_store_->DeleteSessionCookiesAsync(
         base::Bind(&SessionDataDeleter::DeleteSessionCookiesDone, this));
   }
 }
 
 void SessionDataDeleter::DeleteSessionCookiesDone(int num_deleted) {
-  cookie_monster_->GetAllCookiesAsync(
+  cookie_store_->GetAllCookiesAsync(
       base::Bind(&SessionDataDeleter::DeleteSessionOnlyOriginCookies, this));
 }
 
 void SessionDataDeleter::DeleteSessionOnlyOriginCookies(
     const net::CookieList& cookies) {
   if (!storage_policy_.get() || !storage_policy_->HasSessionOnlyOrigins())
     return;
 
   for (net::CookieList::const_iterator it = cookies.begin();
        it != cookies.end();
        ++it) {
     GURL url =
         net::cookie_util::CookieOriginToURL(it->Domain(), it->IsSecure());
     if (!storage_policy_->IsStorageSessionOnly(url))
       continue;
-    cookie_monster_->DeleteCanonicalCookieAsync(*it, base::Bind(CookieDeleted));
+    cookie_store_->DeleteCanonicalCookieAsync(*it, base::Bind(CookieDeleted));
   }
 }
 
 }  // namespace
 
 void DeleteSessionOnlyData(Profile* profile) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (browser_shutdown::IsTryingToQuit())
     return;
 
   // TODO: Remove Athena special casing once the AthenaSessionRestore is in
   // place.
 #if defined(OS_ANDROID)
   SessionStartupPref::Type startup_pref_type =
       SessionStartupPref::GetDefaultStartupType();
 #else
   SessionStartupPref::Type startup_pref_type =
       StartupBrowserCreator::GetSessionStartupPref(
           *base::CommandLine::ForCurrentProcess(), profile).type;
 #endif
 
   scoped_refptr<SessionDataDeleter> deleter(
       new SessionDataDeleter(profile->GetSpecialStoragePolicy(),
                              startup_pref_type == SessionStartupPref::LAST));
   deleter->Run(
       Profile::GetDefaultStoragePartition(profile),
       ProfileIOData::FromResourceContext(profile->GetResourceContext()));
 }