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 26 matching lines @@
 #elif defined(USE_MESSAGEPUMP_LINUX) && !defined(OS_NACL)
 #include "base/message_pump_linux.h"
 #else
 #include "base/message_pump_gtk.h"
 #endif
 
 #endif
 #endif
 
 namespace base {
-
 class HistogramBase;
+class MessageLoopLockTest;
 class RunLoop;
 class ThreadTaskRunnerHandle;
 #if defined(OS_ANDROID)
 class MessagePumpForUI;
 #endif
 
 // A MessageLoop is used to process events for a particular thread.  There is
 // at most one MessageLoop instance per thread.
 //
 // Events include at a minimum Task instances submitted to PostTask and its
@@ skipping 102 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 208 matching lines @@
 #elif defined(OS_POSIX) && !defined(OS_IOS)
   base::MessagePumpLibevent* pump_libevent() {
     return static_cast<base::MessagePumpLibevent*>(pump_.get());
   }
 #endif
 
   scoped_refptr<base::MessagePump> pump_;
 
  private:
   friend class base::RunLoop;
+  friend class base::MessageLoopLockTest;
 
   // A function to encapsulate all the exception handling capability in the
   // stacks around the running of a main message loop.  It will run the message
   // loop in a SEH try block or not depending on the set_SEH_restoration()
   // flag invoking respectively RunInternalInSEHFrame() or RunInternal().
   void RunHandler();
 
 #if defined(OS_WIN)
   __declspec(noinline) void RunInternalInSEHFrame();
 #endif
@@ skipping 15 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.

[jar (doing other things), 2013/04/29 17:27:18]

Reading the whole comment, starting on line 443, perhaps you should re-write
from there (since line 443 is optionally untrue now).  Better might be:

This function attempts to add pending task to our incoming_queue_. The append
can only possibly fail when |use_try_lock| is true.

When |use_try_lock| is true, then this call will avoid blocking if the related
lock is already held, and will in that case (when the lock is contended) fail to
perform the append, and will return false.

If the call succeeds to append to the queue, then this call will return true.

In all cases, the 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.

[cpu_(ooo_6.6-7.5), 2013/04/30 05:26:04]

Done.

+  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_