Introduce OnceClosure and BindOnce

base/callback_forward.h

 // Copyright (c) 2011 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_CALLBACK_FORWARD_H_
 #define BASE_CALLBACK_FORWARD_H_
 
 namespace base {
 namespace internal {
 
 // CopyMode is used to control the copyablity of a Callback.
 // MoveOnly indicates the Callback is not copyable but movable, and Copyable
 // indicates it is copyable and movable.
 enum class CopyMode {
   MoveOnly, Copyable,
 };
 
+enum class RepeatMode {
+  Once,

[dcheng, 2016/09/08 04:09:01]

Super minor optional nit: here, the order is Once, Repeating, but everywhere
else is Repeating, Once.

I think it would be nice to be uniform (my preferred order is Once, Repeating
since we want to guide people to use OnceCallback) but that requires moving more
things around.

Again, this is totally optional and up to you if you want to.

[tzik, 2016/09/12 11:00:34]

Done. I moved all .*Once.* before Repeating.

+  Repeating,
+};
+
 }  // namespace internal
 
 template <typename Signature,
-          internal::CopyMode copy_mode = internal::CopyMode::Copyable>
+          internal::CopyMode copy_mode = internal::CopyMode::Copyable,
+          internal::RepeatMode repeat_mode = internal::RepeatMode::Repeating>
 class Callback;
 
 // Syntactic sugar to make Callback<void()> easier to declare since it
 // will be used in a lot of APIs with delayed execution.
 using Closure = Callback<void()>;
 
+namespace internal {
+
+template <typename Signature>
+using RepeatingCallback = Callback<Signature,
+                                   internal::CopyMode::Copyable,
+                                   internal::RepeatMode::Repeating>;
+template <typename Signature>
+using OnceCallback = Callback<Signature,
+                              internal::CopyMode::MoveOnly,
+                              internal::RepeatMode::Once>;
+using RepeatingClosure = RepeatingCallback<void()>;
+using OnceClosure = OnceCallback<void()>;
+
+}  // namespace internal
 }  // namespace base
 
 #endif  // BASE_CALLBACK_FORWARD_H_