Adding TryPostTask to the message loop

base/message_loop_unittest.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 <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "base/pending_task.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/run_loop.h"
+#include "base/synchronization/waitable_event.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_WIN)
 #include "base/message_pump_win.h"
 #include "base/win/scoped_handle.h"
 #endif
 
 namespace base {
 
+class MessageLoopLockTest {
+ public:
+  static void LockWaitUnLock(MessageLoop* loop,
+                             base::WaitableEvent* caller_wait,
+                             base::WaitableEvent* caller_signal) {
+
+    loop->incoming_queue_lock_.Acquire();
+    caller_wait->Signal();
+    caller_signal->Wait();
+    loop->incoming_queue_lock_.Release();
+  }
+};
+
 // TODO(darin): Platform-specific MessageLoop tests should be grouped together
 // to avoid chopping this file up with so many #ifdefs.
 
 namespace {
 
 class Foo : public RefCounted<Foo> {
  public:
   Foo() : test_count_(0) {
   }
 
@@ skipping 48 matching lines @@
   MessageLoop::current()->PostTask(FROM_HERE, Bind(
       &Foo::Test0, foo.get()));
   MessageLoop::current()->PostTask(FROM_HERE, Bind(
     &Foo::Test1ConstRef, foo.get(), a));
   MessageLoop::current()->PostTask(FROM_HERE, Bind(
       &Foo::Test1Ptr, foo.get(), &b));
   MessageLoop::current()->PostTask(FROM_HERE, Bind(
       &Foo::Test1Int, foo.get(), 100));
   MessageLoop::current()->PostTask(FROM_HERE, Bind(
       &Foo::Test2Ptr, foo.get(), &a, &c));
-  MessageLoop::current()->PostTask(FROM_HERE, Bind(
-      &Foo::Test2Mixed, foo.get(), a, &d));
+
+  // TryPost with no contention. It must succeed.
+  EXPECT_TRUE(MessageLoop::current()->TryPostTask(FROM_HERE, Bind(
+      &Foo::Test2Mixed, foo.get(), a, &d)));
+
+  // TryPost with simulated contention. It must fail. We wait for a helper
+  // thread to lock the queue, we TryPost on this thread and finally we
+  // signal the helper to unlock and exit.
+  WaitableEvent wait(true, false);
+  WaitableEvent signal(true, false);
+  Thread thread("RunTest_PostTask_helper");
+  thread.Start();
+  thread.message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&MessageLoopLockTest::LockWaitUnLock,
+      MessageLoop::current(),
+      &wait,
+      &signal));
+
+  wait.Wait();
+  EXPECT_FALSE(MessageLoop::current()->TryPostTask(FROM_HERE, Bind(
+      &Foo::Test2Mixed, foo.get(), a, &d)));
+  signal.Signal();
 
   // After all tests, post a message that will shut down the message loop
   MessageLoop::current()->PostTask(FROM_HERE, Bind(
       &MessageLoop::Quit, Unretained(MessageLoop::current())));
 
   // Now kick things off
   MessageLoop::current()->Run();
 
   EXPECT_EQ(foo->test_count(), 105);
   EXPECT_EQ(foo->result(), "abacad");
@@ skipping 1965 matching lines @@
   // On Linux, the pipe buffer size is 64KiB by default. The bug caused one
   // byte accumulated in the pipe per two posts, so we should repeat 128K
   // times to reproduce the bug.
   const int kNumTimes = 1 << 17;
   RunTest_RecursivePosts(MessageLoop::TYPE_DEFAULT, kNumTimes);
   RunTest_RecursivePosts(MessageLoop::TYPE_UI, kNumTimes);
   RunTest_RecursivePosts(MessageLoop::TYPE_IO, kNumTimes);
 }
 
 }  // namespace base