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)26CallbackType 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)66RepeatingCallback<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