Remove SequencedWorkerPool::PostWorkerTask().

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>
@@ skipping 37 matching lines @@
 // Example:
 //   SequencedWorkerPool::SequenceToken token = pool.GetSequenceToken();
 //   pool.PostSequencedWorkerTask(token, SequencedWorkerPool::SKIP_ON_SHUTDOWN,
 //                                FROM_HERE, base::Bind(...));
 //   pool.PostSequencedWorkerTask(token, SequencedWorkerPool::SKIP_ON_SHUTDOWN,
 //                                FROM_HERE, base::Bind(...));
 //
 // You can make named sequence tokens to make it easier to share a token
 // across different components.
 //
-// You can also post tasks to the pool without ordering using PostWorkerTask.
+// You can also post tasks to the pool without ordering using PostTask.
 // These will be executed in an unspecified order. The order of execution
 // between tasks with different sequence tokens is also unspecified.
 //
 // You must call EnableForProcess() or
 // EnableWithRedirectionToTaskSchedulerForProcess() before starting to post
 // tasks to a process' SequencedWorkerPools.
 //
 // This class may be leaked on shutdown to facilitate fast shutdown. The
 // expected usage, however, is to call Shutdown(), which correctly accounts
 // for CONTINUE_ON_SHUTDOWN behavior and is required for BLOCK_SHUTDOWN
@@ skipping 179 matching lines @@
       SequenceToken token,
       WorkerShutdown shutdown_behavior) WARN_UNUSED_RESULT;
 
   // Returns a TaskRunner wrapper which posts to this SequencedWorkerPool using
   // the given shutdown behavior. Tasks with nonzero delay are posted with
   // SKIP_ON_SHUTDOWN behavior and tasks with zero delay are posted with the
   // given shutdown behavior.
   scoped_refptr<TaskRunner> GetTaskRunnerWithShutdownBehavior(
       WorkerShutdown shutdown_behavior) WARN_UNUSED_RESULT;
 
-  // Posts the given task for execution in the worker pool. Tasks posted with
-  // this function will execute in an unspecified order on a background thread.
-  // Returns true if the task was posted. If your tasks have ordering
-  // requirements, see PostSequencedWorkerTask().
-  //
-  // This class will attempt to delete tasks that aren't run
-  // (non-block-shutdown semantics) but can't guarantee that this happens. If
-  // all worker threads are busy running CONTINUE_ON_SHUTDOWN tasks, there
-  // will be no workers available to delete these tasks. And there may be
-  // tasks with the same sequence token behind those CONTINUE_ON_SHUTDOWN
-  // 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,
-                      OnceClosure task);
-
   // Same as PostWorkerTask but allows specification of the shutdown behavior.
   bool PostWorkerTaskWithShutdownBehavior(
       const tracked_objects::Location& from_here,
       OnceClosure 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
@@ skipping 105 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_