Introduce a new framework for back-and-forth tracked/protected preferences migration.

base/critical_closure_ios.mm

 // 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 "base/critical_closure.h"
 
 #import <UIKit/UIKit.h>
 
 #include "base/bind.h"
 #include "base/ios/scoped_critical_action.h"
 #include "base/memory/ref_counted.h"
 
 namespace {
 
 // This class wraps a closure so it can continue to run for a period of time
 // when the application goes to the background by using
 // |base::ios::ScopedCriticalAction|.
+template <typename CallbackType>
 class CriticalClosure : public base::RefCountedThreadSafe<CriticalClosure> {
  public:
-  explicit CriticalClosure(base::Closure* closure) : closure_(closure) {
+  explicit CriticalClosure(CallbackType* closure) : closure_(closure) {
   }
 
   void Run() {

[Bernhard Bauer, 2014/04/30 09:31:05]

Hm, this class only implements an argumentless Run() method, so it will only
work with argumentless callbacks, right? I think that shouldn't be a problem
though, because SFINAE.

[gab, 2014/04/30 14:32:53]

Ah good point, I actually made the template more specific to only accept
Callback<R(void)> types; which actually makes more sense (it doesn't really make
sense to have a partially bound critical task IMO).

     closure_->Run();
   }
 
  private:
   friend class base::RefCountedThreadSafe<CriticalClosure>;
 
   virtual ~CriticalClosure() {}
 
   base::ios::ScopedCriticalAction criticial_action_;

[Bernhard Bauer, 2014/04/30 09:31:05]

If you want to clean this up a bit, it should be named |critical_action_| :)

[gab, 2014/04/30 14:32:53]

Done.

-  scoped_ptr<base::Closure> closure_;
+  scoped_ptr<CallbackType> closure_;

[Bernhard Bauer, 2014/04/30 09:31:05]

Oh, and this could probably also directly own the closure.

[gab, 2014/04/30 14:32:53]

Done, and also removed refcounting (whose only purpose was to have the Callback
own the CriticalClosure); using base::Owned() instead.

 
   DISALLOW_COPY_AND_ASSIGN(CriticalClosure);
 };
 
 }  // namespace
 
 namespace base {
 
-base::Closure MakeCriticalClosure(const base::Closure& closure) {
+template <typename CallbackType>
+CallbackType MakeCriticalClosure(const CallbackType& closure) {
   DCHECK([[UIDevice currentDevice] isMultitaskingSupported]);
   scoped_refptr<CriticalClosure> critical_closure(
-      new CriticalClosure(new base::Closure(closure)));
+      new CriticalClosure(new CallbackType(closure)));
   return base::Bind(&CriticalClosure::Run, critical_closure.get());
 }
 
 }  // namespace base