Adding TryPostTask to the message loop

base/message_loop.cc

 // 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.
 
 #include "base/message_loop.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 252 matching lines @@
   destruction_observers_.AddObserver(destruction_observer);
 }
 
 void MessageLoop::RemoveDestructionObserver(
     DestructionObserver* destruction_observer) {
   DCHECK_EQ(this, current());
   destruction_observers_.RemoveObserver(destruction_observer);
 }
 
 void MessageLoop::PostTask(
-    const tracked_objects::Location& from_here, const Closure& task) {
+    const tracked_objects::Location& from_here,
+    const Closure& task) {
   DCHECK(!task.is_null()) << from_here.ToString();
   PendingTask pending_task(
       from_here, task, CalculateDelayedRuntime(TimeDelta()), true);
-  AddToIncomingQueue(&pending_task);
+  AddToIncomingQueue(&pending_task, false);
+}
+
+bool MessageLoop::TryPostTask(
+    const tracked_objects::Location& from_here,
+    const Closure& task) {
+  DCHECK(!task.is_null()) << from_here.ToString();
+  PendingTask pending_task(
+      from_here, task, CalculateDelayedRuntime(TimeDelta()), true);
+  return AddToIncomingQueue(&pending_task, true);
 }
 
 void MessageLoop::PostDelayedTask(
     const tracked_objects::Location& from_here,
     const Closure& task,
     TimeDelta delay) {
   DCHECK(!task.is_null()) << from_here.ToString();
   PendingTask pending_task(
       from_here, task, CalculateDelayedRuntime(delay), true);
-  AddToIncomingQueue(&pending_task);
+  AddToIncomingQueue(&pending_task, false);
 }
 
 void MessageLoop::PostNonNestableTask(
     const tracked_objects::Location& from_here,
     const Closure& task) {
   DCHECK(!task.is_null()) << from_here.ToString();
   PendingTask pending_task(
       from_here, task, CalculateDelayedRuntime(TimeDelta()), false);
-  AddToIncomingQueue(&pending_task);
+  AddToIncomingQueue(&pending_task, false);
 }
 
 void MessageLoop::PostNonNestableDelayedTask(
     const tracked_objects::Location& from_here,
     const Closure& task,
     TimeDelta delay) {
   DCHECK(!task.is_null()) << from_here.ToString();
   PendingTask pending_task(
       from_here, task, CalculateDelayedRuntime(delay), false);
-  AddToIncomingQueue(&pending_task);
+  AddToIncomingQueue(&pending_task, false);
 }
 
 void MessageLoop::Run() {
   RunLoop run_loop;
   run_loop.Run();
 }
 
 void MessageLoop::RunUntilIdle() {
   RunLoop run_loop;
   run_loop.RunUntilIdle();
@@ skipping 262 matching lines @@
       Time::ActivateHighResolutionTimer(false);
       high_resolution_timer_expiration_ = TimeTicks();
     }
   }
 #endif
 
   return delayed_run_time;
 }
 
 // Possibly called on a background thread!
-void MessageLoop::AddToIncomingQueue(PendingTask* pending_task) {
+bool MessageLoop::AddToIncomingQueue(PendingTask* pending_task,
+                                     bool use_try_lock) {
   // Warning: Don't try to short-circuit, and handle this thread's tasks more
   // directly, as it could starve handling of foreign threads.  Put every task
   // into this queue.
 
   scoped_refptr<MessagePump> pump;
   {
-    AutoLock locked(incoming_queue_lock_);
-
+    if (use_try_lock) {
+      if (!incoming_queue_lock_.Try()) {
+        pending_task->task.Reset();
+        return false;
+      }
+    } else {
+      incoming_queue_lock_.Acquire();
+    }
+    AutoLock locked(incoming_queue_lock_, AutoLock::AlreadyAcquired());
     // Initialize the sequence number. The sequence number is used for delayed
     // tasks (to faciliate FIFO sorting when two tasks have the same
     // delayed_run_time value) and for identifying the task in about:tracing.
     pending_task->sequence_num = next_sequence_num_++;
 
     TRACE_EVENT_FLOW_BEGIN0("task", "MessageLoop::PostTask",
         TRACE_ID_MANGLE(GetTaskTraceID(*pending_task, this)));
 
     bool was_empty = incoming_queue_.empty();
     incoming_queue_.push(*pending_task);
     pending_task->task.Reset();
     if (!was_empty)
-      return;  // Someone else should have started the sub-pump.
+      return true;  // Someone else should have started the sub-pump.
 
     pump = pump_;
   }
   // Since the incoming_queue_ may contain a task that destroys this message
   // loop, we cannot exit incoming_queue_lock_ until we are done with |this|.
   // We use a stack-based reference to the message pump so that we can call
   // ScheduleWork outside of incoming_queue_lock_.
 
   pump->ScheduleWork();
+  return true;
 }
 
 //------------------------------------------------------------------------------
 // Method and data for histogramming events and actions taken by each instance
 // on each thread.
 
 void MessageLoop::StartHistogrammer() {
 #if !defined(OS_NACL)  // NaCl build has no metrics code.
   if (enable_histogrammer_ && !message_histogram_
       && StatisticsRecorder::IsActive()) {
@@ skipping 176 matching lines @@
       fd,
       persistent,
       mode,
       controller,
       delegate);
 }
 
 #endif
 
 }  // namespace base