Implement SequencedTaskChecker.

webrtc/base/sequenced_task_checker_unittest.cc

+/*
+ *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+#include "testing/gtest/include/gtest/gtest.h"
+#include "webrtc/base/checks.h"
+#include "webrtc/base/constructormagic.h"
+#include "webrtc/base/platform_thread.h"
+#include "webrtc/base/sequenced_task_checker.h"
+#include "webrtc/base/task_queue.h"
+
+namespace rtc {
+
+namespace {
+// Calls SequencedCheckerClass::PlatformThread on another thread.
+class CallCalledSequentiallyOnThread {
+ public:
+  CallCalledSequentiallyOnThread(bool expect_true,
+                                 SequencedTaskChecker* sequenced_task_checker)
+      : expect_true_(expect_true),
+        thread_(&Run, this, "call_do_stuff_on_thread"),
+        sequenced_task_checker_(sequenced_task_checker) {
+    thread_.Start();
+    thread_.Stop();

[tommi, 2016/07/12 17:19:23]

call Stop() in the dtor? (same below)
How do you guarantee that the call is made?  It looks like if an implementation
detail of PlatformThread were to change, then this would break.  E.g. if you
call Stop() before the thread routine has been called, the thread could be
terminated.

[perkj_webrtc, 2016/07/12 20:50:57]

Done but why would calling stop in the dtor be any better? 
I did read the comment in the link below  before I did the previouse patchet-
but I can create an event and wait for it as as well to be sure if it ever
changes.
https://cs.chromium.org/chromium/src/third_party/webrtc/base/platform_thread....

[tommi, 2016/07/12 21:11:06]

Ah, that's great.  If that's the contract, then it sounds fair to rely on it.
I was actually thinking of the other approach to
ctor: Start()
Run: signal event
dtor: Wait for event to be signaled for some period of time, then Stop(), fail
if timeout.

+  }
+
+ private:
+  static bool Run(void* obj) {
+    CallCalledSequentiallyOnThread* call_stuff_on_thread =
+        static_cast<CallCalledSequentiallyOnThread*>(obj);
+    EXPECT_EQ(
+        call_stuff_on_thread->sequenced_task_checker_->CalledSequentially(),
+        call_stuff_on_thread->expect_true_);

[tommi, 2016/07/12 17:19:23]

nit: expectation first

[perkj_webrtc, 2016/07/12 20:50:57]

Done.

+    return false;
+  }
+
+  const bool expect_true_;
+  PlatformThread thread_;
+  SequencedTaskChecker* const sequenced_task_checker_;
+
+  RTC_DISALLOW_COPY_AND_ASSIGN(CallCalledSequentiallyOnThread);
+};
+
+// Deletes SequencedTaskChecker on a different thread.
+class DeleteThreadCheckerOnThread {
+ public:
+  explicit DeleteThreadCheckerOnThread(
+      std::unique_ptr<SequencedTaskChecker> sequenced_task_checker)
+      : thread_(&Run, this, "delete_sequenced_task_checker_on_thread"),
+        sequenced_task_checker_(std::move(sequenced_task_checker)) {
+    thread_.Start();
+    thread_.Stop();
+  }
+
+ private:
+  static bool Run(void* obj) {
+    static_cast<DeleteThreadCheckerOnThread*>(obj)
+        ->sequenced_task_checker_.reset();
+    return false;
+  }
+
+ private:
+  PlatformThread thread_;
+  std::unique_ptr<SequencedTaskChecker> sequenced_task_checker_;
+
+  RTC_DISALLOW_COPY_AND_ASSIGN(DeleteThreadCheckerOnThread);
+};
+
+void RunMethodOnDifferentThread(bool expect_true) {
+  std::unique_ptr<SequencedTaskChecker> sequenced_task_checker(
+      new SequencedTaskChecker());
+
+  CallCalledSequentiallyOnThread call_on_thread(expect_true,
+                                                sequenced_task_checker.get());
+}
+
+void RunMethodOnDifferentTaskQueue(bool expect_true) {
+  std::unique_ptr<SequencedTaskChecker> sequenced_task_checker(
+      new SequencedTaskChecker());
+
+  static const char kQueueName[] = "MethodNotAllowedOnDifferentTq";
+  TaskQueue queue(kQueueName);
+  Event done_event(false, false);
+  queue.PostTask([&sequenced_task_checker, &done_event, expect_true] {
+    if (expect_true)
+      EXPECT_TRUE(sequenced_task_checker->CalledSequentially());
+    else
+      EXPECT_FALSE(sequenced_task_checker->CalledSequentially());
+    done_event.Set();
+  });
+  EXPECT_TRUE(done_event.Wait(1000));
+}
+
+void DetachThenCallFromDifferentTaskQueue(bool expect_true) {
+  std::unique_ptr<SequencedTaskChecker> sequenced_task_checker(
+      new SequencedTaskChecker());
+
+  sequenced_task_checker->Detach();
+
+  Event done_event(false, false);
+  TaskQueue queue1("DetachThenCallFromDifferentTaskQueueImpl1");
+  queue1.PostTask([&sequenced_task_checker, &done_event] {
+    EXPECT_TRUE(sequenced_task_checker->CalledSequentially());
+    done_event.Set();
+  });
+  EXPECT_TRUE(done_event.Wait(1000));
+
+  // CalledSequentially should return false in debug builds after moving to
+  // another task queue.
+  TaskQueue queue2("DetachThenCallFromDifferentTaskQueueImpl2");
+  queue2.PostTask([&sequenced_task_checker, &done_event, expect_true] {
+    if (expect_true)
+      EXPECT_TRUE(sequenced_task_checker->CalledSequentially());
+    else
+      EXPECT_FALSE(sequenced_task_checker->CalledSequentially());
+    done_event.Set();
+  });
+  done_event.Wait(1000);
+}
+}  // namespace
+
+TEST(SequencedTaskCheckerTest, CallsAllowedOnSameThread) {
+  std::unique_ptr<SequencedTaskChecker> sequenced_task_checker(
+      new SequencedTaskChecker());
+
+  EXPECT_TRUE(sequenced_task_checker->CalledSequentially());
+
+  // Verify that the destructor doesn't assert.
+  sequenced_task_checker.reset();
+}
+
+TEST(SequencedTaskCheckerTest, DestructorAllowedOnDifferentThread) {
+  std::unique_ptr<SequencedTaskChecker> sequenced_task_checker(
+      new SequencedTaskChecker());
+
+  // Verify that the destructor doesn't assert when called on a different
+  // thread.
+  DeleteThreadCheckerOnThread delete_on_thread(
+      std::move(sequenced_task_checker));
+}
+
+TEST(SequencedTaskCheckerTest, DetachFromThread) {
+  std::unique_ptr<SequencedTaskChecker> sequenced_task_checker(
+      new SequencedTaskChecker());
+
+  sequenced_task_checker->Detach();
+  CallCalledSequentiallyOnThread call_on_thread(true,
+                                                sequenced_task_checker.get());
+}
+
+TEST(SequencedTaskCheckerTest, DetachFromThreadAndUseOnTaskQueue) {
+  std::unique_ptr<SequencedTaskChecker> sequenced_task_checker(
+      new SequencedTaskChecker());
+
+  sequenced_task_checker->Detach();
+  static const char kQueueName[] = "DetachFromThreadAndUseOnTaskQueue";
+  TaskQueue queue(kQueueName);
+  Event done_event(false, false);
+  queue.PostTask([&sequenced_task_checker, &done_event] {
+    EXPECT_TRUE(sequenced_task_checker->CalledSequentially());
+    done_event.Set();
+  });
+  EXPECT_TRUE(done_event.Wait(1000));
+}
+
+TEST(SequencedTaskCheckerTest, DetachFromTaskQueueAndUseOnThread) {
+  TaskQueue queue("DetachFromTaskQueueAndUseOnThread");
+  Event done_event(false, false);
+  queue.PostTask([&done_event] {
+    std::unique_ptr<SequencedTaskChecker> sequenced_task_checker(
+        new SequencedTaskChecker());
+
+    sequenced_task_checker->Detach();
+    CallCalledSequentiallyOnThread call_on_thread(true,
+                                                  sequenced_task_checker.get());
+    done_event.Set();
+  });
+  EXPECT_TRUE(done_event.Wait(1000));
+}
+
+#if !NDEBUG || DCHECK_ALWAYS_ON
+TEST(SequencedTaskCheckerTest, MethodNotAllowedOnDifferentThreadInDebug) {
+  RunMethodOnDifferentThread(false);
+}
+#else
+TEST(SequencedTaskCheckerTest, MethodAllowedOnDifferentThreadInRelease) {
+  RunMethodOnDifferentThread(true);
+}
+#endif
+
+#if !NDEBUG || DCHECK_ALWAYS_ON
+TEST(SequencedTaskCheckerTest, MethodNotAllowedOnDifferentTaskQueueInDebug) {
+  RunMethodOnDifferentTaskQueue(false);
+}
+#else
+TEST(SequencedTaskCheckerTest, MethodAllowedOnDifferentTaskQueueInRelease) {
+  RunMethodOnDifferentTaskQueue(true);
+}
+#endif
+
+#if !NDEBUG || DCHECK_ALWAYS_ON
+TEST(SequencedTaskCheckerTest, DetachFromTaskQueueInDebug) {
+  DetachThenCallFromDifferentTaskQueue(false);
+}
+#else
+TEST(SequencedTaskCheckerTest, DetachFromTaskQueueInRelease) {
+  DetachThenCallFromDifferentTaskQueue(true);
+}
+#endif
+
+class TestAnnotations {
+ public:
+  TestAnnotations() : test_var_(false) {}
+
+  void ModifyTestVar() {
+    RTC_DCHECK_CALLED_SEQUENTIALLY(&checker_);
+    test_var_ = true;
+  }
+
+ private:
+  bool test_var_ GUARDED_BY(&checker_);
+  SequencedTaskChecker checker_;
+};
+
+TEST(SequencedTaskCheckerTest, TestAnnotations) {
+  TestAnnotations annotations;
+  annotations.ModifyTestVar();
+}
+
+#if GTEST_HAS_DEATH_TEST

[tommi, 2016/07/12 17:19:22]

check the source code for where we use this. There are some configurations that
are troublesome.

[perkj_webrtc, 2016/07/12 20:50:57]

do not run on android it looks like.

+
+void TestAnnotationsOnWrongQueue() {
+  TestAnnotations annotations;
+  static const char kQueueName[] = "TestAnnotationsOnWrongQueueDebug";
+  TaskQueue queue(kQueueName);
+  Event done_event(false, false);
+  queue.PostTask([&annotations, &done_event] {
+    annotations.ModifyTestVar();
+    done_event.Set();
+  });
+  EXPECT_TRUE(done_event.Wait(1000));
+}
+
+#if !NDEBUG || DCHECK_ALWAYS_ON
+TEST(SequencedTaskCheckerTest, TestAnnotationsOnWrongQueueDebug) {
+  ASSERT_DEATH({ TestAnnotationsOnWrongQueue(); }, "");
+}
+#else
+TEST(SequencedTaskCheckerTest, TestAnnotationsOnWrongQueueRelease) {
+  TestAnnotationsOnWrongQueue();
+}
+#endif
+#endif  // GTEST_HAS_DEATH_TEST
+}  // namespace rtc