Adding TryPostTask to the message loop

base/message_loop.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_MESSAGE_LOOP_H_
 #define BASE_MESSAGE_LOOP_H_
 
 #include <queue>
 #include <string>
 
@@ skipping 150 matching lines @@
   // The NonNestable variants work similarly except that they promise never to
   // dispatch the task from a nested invocation of MessageLoop::Run.  Instead,
   // such tasks get deferred until the top-most MessageLoop::Run is executing.
   //
   // The MessageLoop takes ownership of the Task, and deletes it after it has
   // been Run().
   //
   // PostTask(from_here, task) is equivalent to
   // PostDelayedTask(from_here, task, 0).
   //
+  // The TryPostTask is meant for the cases where the calling thread cannot
+  // block. If posting the task will block, the call returns false, the task
+  // is not posted but the task is consumed anyways.
+  //
   // NOTE: These methods may be called on any thread.  The Task will be invoked
   // on the thread that executes MessageLoop::Run().
   void PostTask(
       const tracked_objects::Location& from_here,
       const base::Closure& task);
 
+  bool TryPostTask(
+      const tracked_objects::Location& from_here,
+      const base::Closure& task);
+
   void PostDelayedTask(
       const tracked_objects::Location& from_here,
       const base::Closure& task,
       base::TimeDelta delay);
 
   void PostNonNestableTask(
       const tracked_objects::Location& from_here,
       const base::Closure& task);
 
   void PostNonNestableDelayedTask(
@@ skipping 243 matching lines @@
 
   // Adds the pending task to delayed_work_queue_.
   void AddToDelayedWorkQueue(const base::PendingTask& pending_task);
 
   // Adds the pending task to our incoming_queue_.
   //
   // Caller retains ownership of |pending_task|, but this function will
   // reset the value of pending_task->task.  This is needed to ensure
   // that the posting call stack does not retain pending_task->task
   // beyond this function call.
-  void AddToIncomingQueue(base::PendingTask* pending_task);
+  // If |use_try_lock| is true, The function fails if another thread is
+  // queuing or dequeing at that moment. In that case the function returns
+  // false. If |use_try_lock| is false there is no need to check the
+  // return value.
+  bool AddToIncomingQueue(base::PendingTask* pending_task, bool use_try_lock);
 
   // Load tasks from the incoming_queue_ into work_queue_ if the latter is
   // empty.  The former requires a lock to access, while the latter is directly
   // accessible on this thread.
   void ReloadWorkQueue();
 
   // Delete tasks that haven't run yet without running them.  Used in the
   // destructor to make sure all the task's destructors get called.  Returns
   // true if some work was done.
   bool DeletePendingTasks();
@@ skipping 262 matching lines @@
 
 }  // namespace base
 
 // TODO(brettw) remove this when all users are updated to explicitly use the
 // namespace
 using base::MessageLoop;
 using base::MessageLoopForIO;
 using base::MessageLoopForUI;
 
 #endif  // BASE_MESSAGE_LOOP_H_