Pass Callback to TaskRunner by value and consume it on invocation (1)

base/threading/sequenced_worker_pool.h

 // Copyright (c) 2012 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_THREADING_SEQUENCED_WORKER_POOL_H_
 #define BASE_THREADING_SEQUENCED_WORKER_POOL_H_
 
 #include <stddef.h>
 
 #include <cstddef>
 #include <memory>
 #include <string>
 
 #include "base/base_export.h"
-#include "base/callback_forward.h"
+#include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/task_runner.h"
 #include "base/task_scheduler/task_traits.h"
 
 namespace tracked_objects {
 class Location;
 }  // namespace tracked_objects
 
@@ skipping 242 matching lines @@
   // tasks. Deleting those tasks before the previous one has completed could
   // cause nondeterministic crashes because the task could be keeping some
   // objects alive which do work in their destructor, which could voilate the
   // assumptions of the running task.
   //
   // The task will be guaranteed to run to completion before shutdown
   // (BLOCK_SHUTDOWN semantics).
   //
   // Returns true if the task was posted successfully. This may fail during
   // shutdown regardless of the specified ShutdownBehavior.
-  bool PostWorkerTask(const tracked_objects::Location& from_here,
-                      const Closure& task);
+  bool PostWorkerTask(const tracked_objects::Location& from_here, Closure task);
 
   // Same as PostWorkerTask but allows a delay to be specified (although doing
   // so changes the shutdown behavior). The task will be run after the given
   // delay has elapsed.
   //
   // If the delay is nonzero, the task won't be guaranteed to run to completion
   // before shutdown (SKIP_ON_SHUTDOWN semantics) to avoid shutdown hangs.
   // If the delay is zero, this behaves exactly like PostWorkerTask, i.e. the
   // task will be guaranteed to run to completion before shutdown
   // (BLOCK_SHUTDOWN semantics).
   bool PostDelayedWorkerTask(const tracked_objects::Location& from_here,
-                             const Closure& task,
+                             Closure task,
                              TimeDelta delay);
 
   // Same as PostWorkerTask but allows specification of the shutdown behavior.
   bool PostWorkerTaskWithShutdownBehavior(
       const tracked_objects::Location& from_here,
-      const Closure& task,
+      Closure task,
       WorkerShutdown shutdown_behavior);
 
   // Like PostWorkerTask above, but provides sequencing semantics. This means
   // that tasks posted with the same sequence token (see GetSequenceToken())
   // are guaranteed to execute in order. This is useful in cases where you're
   // doing operations that may depend on previous ones, like appending to a
   // file.
   //
   // The task will be guaranteed to run to completion before shutdown
   // (BLOCK_SHUTDOWN semantics).
   //
   // Returns true if the task was posted successfully. This may fail during
   // shutdown regardless of the specified ShutdownBehavior.
   bool PostSequencedWorkerTask(SequenceToken sequence_token,
                                const tracked_objects::Location& from_here,
-                               const Closure& task);
+                               Closure task);
 
   // Like PostSequencedWorkerTask above, but allows you to specify a named
   // token, which saves an extra call to GetNamedSequenceToken.
   bool PostNamedSequencedWorkerTask(const std::string& token_name,
                                     const tracked_objects::Location& from_here,
-                                    const Closure& task);
+                                    Closure task);
 
   // Same as PostSequencedWorkerTask but allows a delay to be specified
   // (although doing so changes the shutdown behavior). The task will be run
   // after the given delay has elapsed.
   //
   // If the delay is nonzero, the task won't be guaranteed to run to completion
   // before shutdown (SKIP_ON_SHUTDOWN semantics) to avoid shutdown hangs.
   // If the delay is zero, this behaves exactly like PostSequencedWorkerTask,
   // i.e. the task will be guaranteed to run to completion before shutdown
   // (BLOCK_SHUTDOWN semantics).
   bool PostDelayedSequencedWorkerTask(
       SequenceToken sequence_token,
       const tracked_objects::Location& from_here,
-      const Closure& task,
+      Closure task,
       TimeDelta delay);
 
   // Same as PostSequencedWorkerTask but allows specification of the shutdown
   // behavior.
   bool PostSequencedWorkerTaskWithShutdownBehavior(
       SequenceToken sequence_token,
       const tracked_objects::Location& from_here,
-      const Closure& task,
+      Closure task,
       WorkerShutdown shutdown_behavior);
 
   // TaskRunner implementation. Forwards to PostDelayedWorkerTask().
   bool PostDelayedTask(const tracked_objects::Location& from_here,
-                       const Closure& task,
+                       Closure task,
                        TimeDelta delay) override;
   bool RunsTasksOnCurrentThread() const override;
 
   // Blocks until all pending tasks are complete. This should only be called in
   // unit tests when you want to validate something that should have happened.
   // Does not wait for delayed tasks. If redirection to TaskScheduler is
   // disabled, delayed tasks are deleted. If redirection to TaskScheduler is
   // enabled, this will wait for all tasks posted to TaskScheduler (not just
   // tasks posted to this SequencedWorkerPool).
   //
@@ skipping 52 matching lines @@
   // Avoid pulling in too many headers by putting (almost) everything
   // into |inner_|.
   const std::unique_ptr<Inner> inner_;
 
   DISALLOW_COPY_AND_ASSIGN(SequencedWorkerPool);
 };
 
 }  // namespace base
 
 #endif  // BASE_THREADING_SEQUENCED_WORKER_POOL_H_