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

base/critical_closure.h

 // 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.
 
 #ifndef BASE_CRITICAL_CLOSURE_H_
 #define BASE_CRITICAL_CLOSURE_H_
 
 #include "base/callback.h"
 
+#if defined(OS_IOS)
+#import <UIKit/UIKit.h>

[Nico, 2014/05/06 03:00:10]

wot, why do you need UIKit in base?

That's why this doesn't compile btw: UIKit.h contains ObjC code, but you include
this header from a cc file (sequenced_worker_pool.cc). Only .mm files are
compiled as ObjC++.

[gab, 2014/05/06 14:40:35]

Oh of course, moved that as-is from the .mm file; not sure why it was initially
added there? Potentially for the DCHECK([[UIDevice currentDevice]
isMultitaskingSupported]); ??

I had to remove that DCHECK because it also couldn't build in C++ context.

If you think this DCHECK is required then we could add a helper with a .mm
specific impl; WDYT?

+
+#include "base/bind.h"
+#include "base/ios/scoped_critical_action.h"
+#endif
+
 namespace base {
 
-// Returns a closure that will continue to run for a period of time when the
+namespace internal {
+
+#if defined(OS_IOS)
+// 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
+// |ios::ScopedCriticalAction|.
+template <typename R>
+class CriticalClosure {
+ public:
+  explicit CriticalClosure(const Callback<R(void)>& closure)
+      : closure_(closure) {}
+
+  ~CriticalClosure() {}
+
+  void Run() {
+    closure_.Run();
+  }
+
+ private:
+  ios::ScopedCriticalAction critical_action_;
+  Callback<R(void)> closure_;
+
+  DISALLOW_COPY_AND_ASSIGN(CriticalClosure);
+};
+#endif  // defined(OS_IOS)
+
+}  // namespace internal
+
+// Returns a closure (which may return a result, but must not require any extra
+// arguments) that will continue to run for a period of time when the
 // application goes to the background if possible on platforms where
 // applications don't execute while backgrounded, otherwise the original task is
 // returned.
 //
 // Example:
 //   file_message_loop_proxy_->PostTask(
 //       FROM_HERE,
 //       MakeCriticalClosure(base::Bind(&WriteToDiskTask, path_, data)));
 //
 // Note new closures might be posted in this closure. If the new closures need
 // background running time, |MakeCriticalClosure| should be applied on them
 // before posting.
 #if defined(OS_IOS)
-base::Closure MakeCriticalClosure(const base::Closure& closure);
-#else
-inline base::Closure MakeCriticalClosure(const base::Closure& closure) {
+template <typename R>
+Callback<R(void)> MakeCriticalClosure(const Callback<R(void)>& closure) {
+  DCHECK([[UIDevice currentDevice] isMultitaskingSupported]);
+  return base::Bind(&internals::CriticalClosure<R>::Run,
+                    Owned(new internals::CriticalClosure<R>(closure)));
+}
+#else  // defined(OS_IOS)
+template <typename R>
+inline Callback<R(void)> MakeCriticalClosure(const Callback<R(void)>& closure) {
   // No-op for platforms where the application does not need to acquire
   // background time for closures to finish when it goes into the background.
   return closure;
 }
-#endif  // !defined(OS_IOS)
+#endif  // defined(OS_IOS)
 
 }  // namespace base
 
 #endif  // BASE_CRITICAL_CLOSURE_H_