base/callback_helpers.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // This defines helpful methods for dealing with Callbacks.  Because Callbacks
   6 // are implemented using templates, with a class per callback signature, adding
   7 // methods to Callback<> itself is unattractive (lots of extra code gets
   8 // generated).  Instead, consider adding methods here.
   9
  10 #ifndef BASE_CALLBACK_HELPERS_H_
  11 #define BASE_CALLBACK_HELPERS_H_
  12
  13 #include <utility>
  14
  15 #include "base/atomicops.h"
  16 #include "base/bind.h"
  17 #include "base/callback.h"
  18 #include "base/compiler_specific.h"
  19 #include "base/macros.h"
  20 #include "base/memory/ptr_util.h"
  21
  22 namespace base {
  23
  24 // Prefer std::move() over ResetAndReturn().
  25 template <typename CallbackType>
  26 CallbackType ResetAndReturn(CallbackType* cb) {
  27   CallbackType ret(std::move(*cb));
  28   DCHECK(!*cb);
  29   return ret;
  30 }
  31
  32 namespace internal {
  33
  34 template <typename... Args>
  35 class AdaptCallbackForRepeatingHelper final {
  36  public:
  37   explicit AdaptCallbackForRepeatingHelper(OnceCallback<void(Args...)> callback)
  38       : callback_(std::move(callback)) {
  39     DCHECK(callback_);
  40   }
  41
  42   void Run(Args... args) {
  43     if (subtle::NoBarrier_AtomicExchange(&has_run_, 1))
  44       return;
  45     DCHECK(callback_);
  46     std::move(callback_).Run(std::forward<Args>(args)...);
  47   }
  48
  49  private:
  50   volatile subtle::Atomic32 has_run_ = 0;
  51   base::OnceCallback<void(Args...)> callback_;
  52
  53   DISALLOW_COPY_AND_ASSIGN(AdaptCallbackForRepeatingHelper);
  54 };
  55
  56 }  // namespace internal
  57
  58 // Wraps the given OnceCallback into a RepeatingCallback that relays its
  59 // invocation to the original OnceCallback on the first invocation. The
  60 // following invocations are just ignored.
  61 //
  62 // Note that this deliberately subverts the Once/Repeating paradigm of Callbacks
  63 // but helps ease the migration from old-style Callbacks. Avoid if possible; use
  64 // if necessary for migration. TODO(tzik): Remove it. https://crbug.com/730593
  65 template <typename... Args>
  66 RepeatingCallback<void(Args...)> AdaptCallbackForRepeating(
  67     OnceCallback<void(Args...)> callback) {
  68   using Helper = internal::AdaptCallbackForRepeatingHelper<Args...>;
  69   return base::BindRepeating(&Helper::Run,
  70                              std::make_unique<Helper>(std::move(callback)));
  71 }
  72
  73 // ScopedClosureRunner is akin to std::unique_ptr<> for Closures. It ensures
  74 // that the Closure is executed no matter how the current scope exits.
  75 class BASE_EXPORT ScopedClosureRunner {
  76  public:
  77   ScopedClosureRunner();
  78   explicit ScopedClosureRunner(OnceClosure closure);
  79   ~ScopedClosureRunner();
  80
  81   ScopedClosureRunner(ScopedClosureRunner&& other);
  82
  83   // Releases the current closure if it's set and replaces it with the closure
  84   // from |other|.
  85   ScopedClosureRunner& operator=(ScopedClosureRunner&& other);
  86
  87   // Calls the current closure and resets it, so it wont be called again.
  88   void RunAndReset();
  89
  90   // Replaces closure with the new one releasing the old one without calling it.
  91   void ReplaceClosure(OnceClosure closure);
  92
  93   // Releases the Closure without calling.
  94   OnceClosure Release() WARN_UNUSED_RESULT;
  95
  96  private:
  97   OnceClosure closure_;
  98
  99   DISALLOW_COPY_AND_ASSIGN(ScopedClosureRunner);
 100 };
 101
 102 }  // namespace base
 103
 104 #endif  // BASE_CALLBACK_HELPERS_H_