• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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>
ResetAndReturn(CallbackType * cb)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:
AdaptCallbackForRepeatingHelper(OnceCallback<void (Args...)> callback)37   explicit AdaptCallbackForRepeatingHelper(OnceCallback<void(Args...)> callback)
38       : callback_(std::move(callback)) {
39     DCHECK(callback_);
40   }
41 
Run(Args...args)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>
AdaptCallbackForRepeating(OnceCallback<void (Args...)> callback)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_
105