Add CookieStore::DeleteSessionCookiesAsync method.

net/cookies/cookie_monster_unittest.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.
 
 #include "net/cookies/cookie_store_unittest.h"
 
 #include <time.h>
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 455 matching lines @@
     DCHECK(cm);
     SetCookieCallback callback;
     cm->DeleteCanonicalCookieAsync(
         cookie,
         base::Bind(&SetCookieCallback::Run, base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
     return callback.result();
   }
 
+  int DeleteSessionCookies(CookieMonster*cm) {
+    DCHECK(cm);
+    DeleteCallback callback;
+    cm->DeleteSessionCookiesAsync(
+        base::Bind(&DeleteCallback::Run, base::Unretained(&callback)));
+    RunFor(kTimeout);
+    EXPECT_TRUE(callback.did_run());
+    return callback.num_deleted();
+  }
+
   // Helper for DeleteAllForHost test; repopulates CM with same layout
   // each time.
   void PopulateCmForDeleteAllForHost(scoped_refptr<CookieMonster> cm) {
     GURL url_top_level_domain_plus_1(kTopLevelDomainPlus1);
     GURL url_top_level_domain_plus_2(kTopLevelDomainPlus2);
     GURL url_top_level_domain_plus_2_secure(kTopLevelDomainPlus2Secure);
     GURL url_top_level_domain_plus_3(kTopLevelDomainPlus3);
     GURL url_other(kOtherDomain);
 
     DeleteAll(cm);
@@ skipping 264 matching lines @@
 }
 
 ACTION_P3(GetAllCookiesForUrlAction, cookie_monster, url, callback) {
   cookie_monster->GetAllCookiesForURLAsync(url, callback->AsCallback());
 }
 
 ACTION_P(PushCallbackAction, callback_vector) {
   callback_vector->push(arg1);
 }
 
+ACTION_P2(DeleteSessionCookiesAction, cookie_monster, callback) {
+  cookie_monster->DeleteSessionCookiesAsync(callback->AsCallback());
+}
+
 }  // namespace
 
 // This test suite verifies the task deferral behaviour of the CookieMonster.
 // Specifically, for each asynchronous method, verify that:
 // 1. invoking it on an uninitialized cookie store causes the store to begin
 //    chain-loading its backing data or loading data for a specific domain key
 //    (eTLD+1).
 // 2. The initial invocation does not complete until the loading completes.
 // 3. Invocations after the loading has completed complete immediately.
 class DeferredCookieTaskTest : public CookieMonsterTest {
@@ skipping 319 matching lines @@
 
   EXPECT_CALL(delete_cookie_callback, Invoke(false)).WillOnce(
       DeleteCanonicalCookieAction(
       &cookie_monster(), cookie, &delete_cookie_callback));
   EXPECT_CALL(delete_cookie_callback, Invoke(false)).WillOnce(
       QuitCurrentMessageLoop());
 
   CompleteLoadingAndWait();
 }
 
+TEST_F(DeferredCookieTaskTest, DeferredDeleteSessionCookies) {
+  MockDeleteCallback delete_callback;
+
+  BeginWith(DeleteSessionCookiesAction(
+      &cookie_monster(), &delete_callback));
+
+  WaitForLoadCall();
+
+  EXPECT_CALL(delete_callback, Invoke(false)).WillOnce(
+      DeleteSessionCookiesAction(&cookie_monster(), &delete_callback));
+  EXPECT_CALL(delete_callback, Invoke(false)).WillOnce(
+      QuitCurrentMessageLoop());
+
+  CompleteLoadingAndWait();
+}
+
 // Verify that a series of queued tasks are executed in order upon loading of
 // the backing store and that new tasks received while the queued tasks are
 // being dispatched go to the end of the queue.
 TEST_F(DeferredCookieTaskTest, DeferredTaskOrder) {
   DeclareLoadedCookie("www.google.izzle",
                       "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
                       Time::Now() + TimeDelta::FromDays(3));
 
   MockGetCookiesCallback get_cookies_callback;
   MockSetCookiesCallback set_cookies_callback;
@@ skipping 1294 matching lines @@
   }
 
   void DeleteCanonicalCookieTask(CookieMonster* cm,
                                  const CookieMonster::CanonicalCookie& cookie,
                                  SetCookieCallback* callback) {
     cm->DeleteCanonicalCookieAsync(
         cookie,
         base::Bind(&SetCookieCallback::Run, base::Unretained(callback)));
   }
 
+  void DeleteSessionCookiesTask(CookieMonster* cm, DeleteCallback* callback) {
+    cm->DeleteSessionCookiesAsync(
+        base::Bind(&DeleteCallback::Run, base::Unretained(callback)));
+  }
+
  protected:
   void RunOnOtherThread(const base::Closure& task) {
     other_thread_.Start();
     other_thread_.message_loop()->PostTask(FROM_HERE, task);
     RunFor(kTimeout);
     other_thread_.Stop();
   }
 
   Thread other_thread_;
 };
@@ skipping 137 matching lines @@
   it = cookies.begin();
   base::Closure task = base::Bind(
       &net::MultiThreadedCookieMonsterTest::DeleteCanonicalCookieTask,
       base::Unretained(this),
       cm, *it, &callback);
   RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
   EXPECT_TRUE(callback.result());
 }
 
+TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckDeleteSessionCookies) {
+  scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
+  CookieOptions options;
+  EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "A=B", options));
+  EXPECT_TRUE(SetCookieWithOptions(cm, url_google_,
+                                   "B=C; expires=Mon, 18-Apr-22 22:50:13 GMT",
+                                   options));
+  EXPECT_EQ(1, DeleteSessionCookies(cm));
+  EXPECT_EQ(0, DeleteSessionCookies(cm));
+
+  EXPECT_TRUE(SetCookieWithOptions(cm, url_google_, "A=B", options));
+  DeleteCallback callback(&other_thread_);
+  base::Closure task = base::Bind(
+      &net::MultiThreadedCookieMonsterTest::DeleteSessionCookiesTask,
+      base::Unretained(this),
+      cm, &callback);
+  RunOnOtherThread(task);
+  EXPECT_TRUE(callback.did_run());
+  EXPECT_EQ(1, callback.num_deleted());
+}
+
 TEST_F(CookieMonsterTest, ShortLivedSessionCookies) {
   scoped_refptr<MockPersistentCookieStore> store(
       new MockPersistentCookieStore);
   scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL));
 
   // Create a short-lived session cookie.
   CookieOptions options;
   options.set_force_session();
   Time current = Time::Now();
   EXPECT_TRUE(SetCookieWithOptions(cm, url_google_,
@@ skipping 98 matching lines @@
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[4].type);
 
   // Create some non-persistent cookies and check that they don't go to the
   // persistent storage.
   EXPECT_TRUE(SetCookie(cm, url_google_, "B=Bar"));
   this->MatchCookieLines("A=Foo; B=Bar", GetCookies(cm, url_google_));
   EXPECT_EQ(5u, store->commands().size());
 }
 
 }  // namespace net