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 512 matching lines @@
 
 void CookieMonster::GetAllCookiesForURLWithOptionsTask::Run() {
   if (!callback_.is_null()) {
     CookieList cookies = this->cookie_monster()->
         GetAllCookiesForURLWithOptions(url_, options_);
     this->InvokeCallback(base::Bind(&CookieMonster::GetCookieListCallback::Run,
                                     base::Unretained(&callback_), cookies));
   }
 }
 
+// Base task class for Delete*Task.
+template <typename Callback, typename Result>
+class CookieMonster::DeleteTask : public CookieMonster::CookieMonsterTask {
+ public:
+  DeleteTask(CookieMonster* cookie_monster,
+             const Callback& callback)
+      : CookieMonsterTask(cookie_monster),
+        callback_(callback) {
+  }
+
+  // Runs the delete task and returns a result.
+  virtual Result RunDeleteTask() = 0;
+
+  // CookieMonster::CookieMonsterTask:
+  virtual void Run() OVERRIDE;
+
+  void FlushDone(const base::Closure& callback);
+
+ private:
+  Callback callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(DeleteTask);
+};
+
+template <typename Callback, typename Result>
+base::Closure RunDeleteTaskAndBindCallback(
+    CookieMonster::DeleteTask<Callback, Result>* task,
+    const Callback& callback) {
+  return base::Bind(callback, task->RunDeleteTask());
+}
+
+template <typename Callback>

[philipj_slow, 2013/09/05 14:39:12]

I wanted to do this:

template <>
base::Closure RunDeleteTaskAndBindCallback(
    CookieMonster::DeleteTask<base::Closure, void>* task,
    const base::Closure& callback) {
  task->RunDeleteTask();
  return callback;
}

But GCC disapproves:

../../net/cookies/cookie_monster.h:314:55: error: ‘template<class Callback,
class Result> class net::CookieMonster::DeleteTask’ is private
../../net/cookies/cookie_monster.cc:567:34: error: within this context

Not sure why that is.

[erikwright (departed), 2013/09/05 20:28:18]

Presumably in cookie_monster.h the declaration of 'class DeleteTask' is in the
private section.

The struct-based approach, with the struct being declared inline in
DeleteTask::Run, would probably work, as follows:

template <typename Result> void CookieMonster::DeleteTask<Result>::Run() {
  template <typename Result> struct Helper {
    base::Closure RunDeleteTask(
        DeleteTask<Result>* task,
        const base::Callback<void(Result)>& callback) {
      return base::Bind(callback, task->RunDeleteTask());
    }
  };

  template <> struct Helper<void> {
    base::Closure RunDeleteTask(
        DeleteTask<void>* task,
        const base::Closure& callback) {
      task->RunDeleteTask();
      return callback;
    }
  };

  this->cookie_monster()->FlushStore(
      base:Bind(&CookieMonster::DeleteTask::FlushDone, this,
                Helper::RunDeleteTask(this, callback_)));
}


If that doesn't work, you could make the struct a nested class of DeleteTask
too.

+base::Closure RunDeleteTaskAndBindCallback(
+    CookieMonster::DeleteTask<Callback, void>* task,
+    const Callback& callback) {
+  task->RunDeleteTask();
+  return callback;
+}
+
+template <typename Callback, typename Result>
+void CookieMonster::DeleteTask<Callback, Result>::Run() {
+  this->cookie_monster()->FlushStore(
+      base::Bind(&CookieMonster::DeleteTask<Callback, Result>::FlushDone, this,
+                 RunDeleteTaskAndBindCallback(this, callback_)));
+}
+
+template <typename Callback, typename Result>
+void CookieMonster::DeleteTask<Callback, Result>::FlushDone(
+    const base::Closure& callback) {
+  if (!callback.is_null()) {
+    this->InvokeCallback(callback);
+  }
+}
+
 // Task class for DeleteAll call.
-class CookieMonster::DeleteAllTask : public CookieMonster::CookieMonsterTask {
+class CookieMonster::DeleteAllTask
+    : public CookieMonster::DeleteTask<CookieMonster::DeleteCallback, int> {
  public:
   DeleteAllTask(CookieMonster* cookie_monster,
                 const CookieMonster::DeleteCallback& callback)
-      : CookieMonsterTask(cookie_monster),
-        callback_(callback) {
+      : DeleteTask(cookie_monster, callback) {
   }
 
-  // CookieMonster::CookieMonsterTask:
-  virtual void Run() OVERRIDE;
+  // CookieMonster::DeleteTask:
+  virtual int RunDeleteTask() OVERRIDE;
 
  protected:
   virtual ~DeleteAllTask() {}
 
  private:
-  CookieMonster::DeleteCallback callback_;
-
   DISALLOW_COPY_AND_ASSIGN(DeleteAllTask);
 };
 
-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));
-  }
+int CookieMonster::DeleteAllTask::RunDeleteTask() {
+  return this->cookie_monster()->DeleteAll(true);
 }
 
 // Task class for DeleteAllCreatedBetween call.
 class CookieMonster::DeleteAllCreatedBetweenTask
-    : public CookieMonster::CookieMonsterTask {
+    : public CookieMonster::DeleteTask<CookieMonster::DeleteCallback, int> {
  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;
+  // CookieMonster::DeleteTask:
+  virtual int RunDeleteTask() OVERRIDE;
 
  protected:
   virtual ~DeleteAllCreatedBetweenTask() {}
 
  private:
   Time delete_begin_;
   Time delete_end_;
-  CookieMonster::DeleteCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteAllCreatedBetweenTask);
 };
 
-void CookieMonster::DeleteAllCreatedBetweenTask::Run() {
-  int num_deleted = this->cookie_monster()->
+int CookieMonster::DeleteAllCreatedBetweenTask::RunDeleteTask() {
+  return this->cookie_monster()->
       DeleteAllCreatedBetween(delete_begin_, delete_end_);
-  if (!callback_.is_null()) {
-    this->InvokeCallback(base::Bind(&CookieMonster::DeleteCallback::Run,
-                                    base::Unretained(&callback_), num_deleted));
-  }
 }
 
 // Task class for DeleteAllForHost call.
 class CookieMonster::DeleteAllForHostTask
-    : public CookieMonster::CookieMonsterTask {
+    : public CookieMonster::DeleteTask<CookieMonster::DeleteCallback, int> {
  public:
   DeleteAllForHostTask(CookieMonster* cookie_monster,
                        const GURL& url,
                        const CookieMonster::DeleteCallback& callback)
-      : CookieMonsterTask(cookie_monster),
-        url_(url),
-        callback_(callback) {
+      : DeleteTask(cookie_monster, callback),
+        url_(url) {
   }
 
-  // CookieMonster::CookieMonsterTask:
-  virtual void Run() OVERRIDE;
+  // CookieMonster::DeleteTask:
+  virtual int RunDeleteTask() OVERRIDE;
 
  protected:
   virtual ~DeleteAllForHostTask() {}
 
  private:
   GURL url_;
-  CookieMonster::DeleteCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteAllForHostTask);
 };
 
-void CookieMonster::DeleteAllForHostTask::Run() {
-  int num_deleted = this->cookie_monster()->DeleteAllForHost(url_);
-  if (!callback_.is_null()) {
-    this->InvokeCallback(base::Bind(&CookieMonster::DeleteCallback::Run,
-                                    base::Unretained(&callback_), num_deleted));
-  }
+int CookieMonster::DeleteAllForHostTask::RunDeleteTask() {
+  return this->cookie_monster()->DeleteAllForHost(url_);
 }
 
 // Task class for DeleteAllCreatedBetweenForHost call.
 class CookieMonster::DeleteAllCreatedBetweenForHostTask
-    : public CookieMonster::CookieMonsterTask {
+    : public CookieMonster::DeleteTask<CookieMonster::DeleteCallback, int> {
  public:
   DeleteAllCreatedBetweenForHostTask(
       CookieMonster* cookie_monster,
       Time delete_begin,
       Time delete_end,
       const GURL& url,
       const CookieMonster::DeleteCallback& callback)
-      : CookieMonsterTask(cookie_monster),
+      : DeleteTask(cookie_monster, callback),
         delete_begin_(delete_begin),
         delete_end_(delete_end),
-        url_(url),
-        callback_(callback) {
+        url_(url) {
   }
 
-  // CookieMonster::CookieMonsterTask:
-  virtual void Run() OVERRIDE;
+  // CookieMonster::DeleteTask:
+  virtual int RunDeleteTask() OVERRIDE;
 
  protected:
   virtual ~DeleteAllCreatedBetweenForHostTask() {}
 
  private:
   Time delete_begin_;
   Time delete_end_;
   GURL url_;
-  CookieMonster::DeleteCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteAllCreatedBetweenForHostTask);
 };
 
-void CookieMonster::DeleteAllCreatedBetweenForHostTask::Run() {
-  int num_deleted = this->cookie_monster()->DeleteAllCreatedBetweenForHost(
+int CookieMonster::DeleteAllCreatedBetweenForHostTask::RunDeleteTask() {
+  return this->cookie_monster()->DeleteAllCreatedBetweenForHost(
       delete_begin_, delete_end_, url_);
-  if (!callback_.is_null()) {
-    this->InvokeCallback(base::Bind(&CookieMonster::DeleteCallback::Run,
-                                    base::Unretained(&callback_), num_deleted));
-  }
 }
 
 // Task class for DeleteCanonicalCookie call.
 class CookieMonster::DeleteCanonicalCookieTask
-    : public CookieMonster::CookieMonsterTask {
+    : public CookieMonster::DeleteTask<CookieMonster::DeleteCookieCallback, bool> {
  public:
   DeleteCanonicalCookieTask(CookieMonster* cookie_monster,
                             const CanonicalCookie& cookie,
                             const CookieMonster::DeleteCookieCallback& callback)
-      : CookieMonsterTask(cookie_monster),
-        cookie_(cookie),
-        callback_(callback) {
+      : DeleteTask(cookie_monster, callback),
+        cookie_(cookie) {
   }
 
-  // CookieMonster::CookieMonsterTask:
-  virtual void Run() OVERRIDE;
+  // CookieMonster::DeleteTask:
+  virtual bool RunDeleteTask() OVERRIDE;
 
  protected:
   virtual ~DeleteCanonicalCookieTask() {}
 
  private:
   CanonicalCookie cookie_;
-  CookieMonster::DeleteCookieCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteCanonicalCookieTask);
 };
 
-void CookieMonster::DeleteCanonicalCookieTask::Run() {
-  bool result = this->cookie_monster()->DeleteCanonicalCookie(cookie_);
-  if (!callback_.is_null()) {
-    this->InvokeCallback(base::Bind(&CookieMonster::DeleteCookieCallback::Run,
-                                    base::Unretained(&callback_), result));
-  }
+bool CookieMonster::DeleteCanonicalCookieTask::RunDeleteTask() {
+  return this->cookie_monster()->DeleteCanonicalCookie(cookie_);
 }
 
 // Task class for SetCookieWithOptions call.
 class CookieMonster::SetCookieWithOptionsTask
     : public CookieMonster::CookieMonsterTask {
  public:
   SetCookieWithOptionsTask(CookieMonster* cookie_monster,
                            const GURL& url,
                            const std::string& cookie_line,
                            const CookieOptions& options,
@@ skipping 61 matching lines @@
   std::string cookie = this->cookie_monster()->
       GetCookiesWithOptions(url_, options_);
   if (!callback_.is_null()) {
     this->InvokeCallback(base::Bind(&CookieMonster::GetCookiesCallback::Run,
                                     base::Unretained(&callback_), cookie));
   }
 }
 
 // Task class for DeleteCookie call.
 class CookieMonster::DeleteCookieTask
-    : public CookieMonster::CookieMonsterTask {
+    : public CookieMonster::DeleteTask<base::Closure, void> {
  public:
   DeleteCookieTask(CookieMonster* cookie_monster,
                    const GURL& url,
                    const std::string& cookie_name,
                    const base::Closure& callback)
-      : CookieMonsterTask(cookie_monster),
+      : DeleteTask(cookie_monster, callback),
         url_(url),
-        cookie_name_(cookie_name),
-        callback_(callback) { }
+        cookie_name_(cookie_name) {
+  }
 
-  // CookieMonster::CookieMonsterTask:
-  virtual void Run() OVERRIDE;
+  // CookieMonster::DeleteTask:
+  virtual void RunDeleteTask() OVERRIDE;
 
  protected:
   virtual ~DeleteCookieTask() {}
 
  private:
   GURL url_;
   std::string cookie_name_;
-  base::Closure callback_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteCookieTask);
 };
 
-void CookieMonster::DeleteCookieTask::Run() {
+void CookieMonster::DeleteCookieTask::RunDeleteTask() {
   this->cookie_monster()->DeleteCookie(url_, cookie_name_);
-  if (!callback_.is_null()) {
-    this->InvokeCallback(callback_);
-  }
 }
 
 // Task class for DeleteSessionCookies call.
 class CookieMonster::DeleteSessionCookiesTask
-    : public CookieMonster::CookieMonsterTask {
+    : public CookieMonster::DeleteTask<CookieMonster::DeleteCallback, int> {
  public:
   DeleteSessionCookiesTask(CookieMonster* cookie_monster,
                            const CookieMonster::DeleteCallback& callback)
-      : CookieMonsterTask(cookie_monster), callback_(callback) {
+      : DeleteTask(cookie_monster, callback) {
   }
 
-  // CookieMonster::CookieMonsterTask:
-  virtual void Run() OVERRIDE;
+  // CookieMonster::DeleteTask:
+  virtual int RunDeleteTask() OVERRIDE;
 
  protected:
   virtual ~DeleteSessionCookiesTask() {}
 
  private:
-  CookieMonster::DeleteCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteSessionCookiesTask);
 };
 
-void CookieMonster::DeleteSessionCookiesTask::Run() {
-  int num_deleted = this->cookie_monster()->DeleteSessionCookies();
-  if (!callback_.is_null()) {
-    this->InvokeCallback(base::Bind(&CookieMonster::DeleteCallback::Run,
-                                    base::Unretained(&callback_), num_deleted));
-  }
+int CookieMonster::DeleteSessionCookiesTask::RunDeleteTask() {
+  return this->cookie_monster()->DeleteSessionCookies();
 }
 
 // Task class for HasCookiesForETLDP1Task call.
 class CookieMonster::HasCookiesForETLDP1Task
     : public CookieMonster::CookieMonsterTask {
  public:
   HasCookiesForETLDP1Task(
       CookieMonster* cookie_monster,
       const std::string& etldp1,
       const CookieMonster::HasCookiesForETLDP1Callback& callback)
@@ skipping 1360 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