Wait for store flush in CookieMonster::Delete*Task

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 541 matching lines @@
 };
 
 void CookieMonster::DeleteAllTask::Run() {
   int num_deleted = this->cookie_monster()->DeleteAll(true);
   if (!callback_.is_null()) {
     this->InvokeCallback(base::Bind(&CookieMonster::DeleteCallback::Run,
                                     base::Unretained(&callback_), num_deleted));
   }
 }
 
+// Base task class for Delete*Task.
+class CookieMonster::DeleteTask
+    : public CookieMonster::CookieMonsterTask {
+ public:
+  DeleteTask(CookieMonster* cookie_monster,
+             const CookieMonster::DeleteCallback& callback)
+      : CookieMonsterTask(cookie_monster),
+        callback_(callback) {
+  }
+
+  void FlushDone(int num_deleted);
+
+ private:
+  CookieMonster::DeleteCallback callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(DeleteTask);
+};
+
+void CookieMonster::DeleteTask::FlushDone(int num_deleted) {
+  if (!callback_.is_null()) {
+    this->InvokeCallback(base::Bind(&CookieMonster::DeleteCallback::Run,
+                                    base::Unretained(&callback_), num_deleted));
+  }
+}
+
 // Task class for DeleteAllCreatedBetween call.
 class CookieMonster::DeleteAllCreatedBetweenTask
-    : public CookieMonster::CookieMonsterTask {
+    : public CookieMonster::DeleteTask {
  public:
   DeleteAllCreatedBetweenTask(CookieMonster* cookie_monster,
                               const Time& delete_begin,
                               const Time& delete_end,
                               const CookieMonster::DeleteCallback& callback)
-      : CookieMonsterTask(cookie_monster),
+      : DeleteTask(cookie_monster, callback),
         delete_begin_(delete_begin),
-        delete_end_(delete_end),
-        callback_(callback) {
+        delete_end_(delete_end) {
   }
 
   // CookieMonster::CookieMonsterTask:
   virtual void Run() OVERRIDE;
 
  protected:
   virtual ~DeleteAllCreatedBetweenTask() {}
 
  private:
   Time delete_begin_;
   Time delete_end_;
-  CookieMonster::DeleteCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteAllCreatedBetweenTask);
 };
 
 void CookieMonster::DeleteAllCreatedBetweenTask::Run() {

[erikwright (departed), 2013/08/09 17:31:51]

Pull this method up to DeleteTask and delegate to a pure-virtual protected
method:

virtual int RunDeleteTask();

Then the subclass just needs to implement 

int RunDeleteTask() {
  return this->cookie_monster()->DeleteAll...(...);
}

The call to Bind and Flush will only appear in DeleteTask::Run.

DeleteTask may be private.

   int num_deleted = this->cookie_monster()->
       DeleteAllCreatedBetween(delete_begin_, delete_end_);
-  if (!callback_.is_null()) {
-    this->InvokeCallback(base::Bind(&CookieMonster::DeleteCallback::Run,
-                                    base::Unretained(&callback_), num_deleted));
-  }
+  this->cookie_monster()->FlushStore(
+      base::Bind(&CookieMonster::DeleteTask::FlushDone, this, num_deleted));
 }
 
 // Task class for DeleteAllForHost call.
 class CookieMonster::DeleteAllForHostTask
     : public CookieMonster::CookieMonsterTask {
  public:
   DeleteAllForHostTask(CookieMonster* cookie_monster,
                        const GURL& url,
                        const CookieMonster::DeleteCallback& callback)
       : CookieMonsterTask(cookie_monster),
@@ skipping 1543 matching lines @@
 
 // The system resolution is not high enough, so we can have multiple
 // set cookies that result in the same system time.  When this happens, we
 // increment by one Time unit.  Let's hope computers don't get too fast.
 Time CookieMonster::CurrentTime() {
   return std::max(Time::Now(),
       Time::FromInternalValue(last_time_seen_.ToInternalValue() + 1));
 }
 
 }  // namespace net