Home | History | Annotate | Download | only in base 
      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_
    105