Repo created

TMessagesProj/jni/voip/webrtc/base/sequence_checker_impl.cc

@@ -0,0 +1,91 @@
+// 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/sequence_checker_impl.h"
+
+#include "base/logging.h"
+#include "base/memory/ptr_util.h"
+#include "base/sequence_token.h"
+#include "base/threading/thread_checker_impl.h"
+#include "base/threading/thread_local_storage.h"
+
+namespace base {
+
+class SequenceCheckerImpl::Core {
+ public:
+  Core() : sequence_token_(SequenceToken::GetForCurrentThread()) {}
+
+  ~Core() = default;
+
+  bool CalledOnValidSequence() const {
+    // SequenceToken::GetForCurrentThread() accesses thread-local storage.
+    // During destruction the state of thread-local storage is not guaranteed to
+    // be in a consistent state. Further, task-runner only installs the
+    // SequenceToken when running a task. For this reason, |sequence_token_| is
+    // not checked during thread destruction.
+    if (!SequenceCheckerImpl::HasThreadLocalStorageBeenDestroyed() &&
+        sequence_token_.IsValid()) {
+      return sequence_token_ == SequenceToken::GetForCurrentThread();
+    }
+
+    // SequenceChecker behaves as a ThreadChecker when it is not bound to a
+    // valid sequence token.
+    return thread_checker_.CalledOnValidThread();
+  }
+
+ private:
+  SequenceToken sequence_token_;
+
+  // Used when |sequence_token_| is invalid, or during thread destruction.
+  ThreadCheckerImpl thread_checker_;
+};
+
+SequenceCheckerImpl::SequenceCheckerImpl() : core_(std::make_unique<Core>()) {}
+SequenceCheckerImpl::~SequenceCheckerImpl() = default;
+
+SequenceCheckerImpl::SequenceCheckerImpl(SequenceCheckerImpl&& other) {
+  // Verify that |other| is called on its associated sequence and bind it now if
+  // it is currently detached (even if this isn't a DCHECK build).
+  const bool other_called_on_valid_sequence = other.CalledOnValidSequence();
+  DCHECK(other_called_on_valid_sequence);
+
+  core_ = std::move(other.core_);
+}
+
+SequenceCheckerImpl& SequenceCheckerImpl::operator=(
+    SequenceCheckerImpl&& other) {
+  // If |this| is not in a detached state it needs to be bound to the current
+  // sequence.
+  DCHECK(CalledOnValidSequence());
+
+  // Verify that |other| is called on its associated sequence and bind it now if
+  // it is currently detached (even if this isn't a DCHECK build).
+  const bool other_called_on_valid_sequence = other.CalledOnValidSequence();
+  DCHECK(other_called_on_valid_sequence);
+
+  // Intentionally not using either |lock_| in this method to let TSAN catch
+  // racy assign.
+  TS_UNCHECKED_READ(core_) = std::move(TS_UNCHECKED_READ(other.core_));
+
+  return *this;
+}
+
+bool SequenceCheckerImpl::CalledOnValidSequence() const {
+  AutoLock auto_lock(lock_);
+  if (!core_)
+    core_ = std::make_unique<Core>();
+  return core_->CalledOnValidSequence();
+}
+
+void SequenceCheckerImpl::DetachFromSequence() {
+  AutoLock auto_lock(lock_);
+  core_.reset();
+}
+
+// static
+bool SequenceCheckerImpl::HasThreadLocalStorageBeenDestroyed() {
+  return ThreadLocalStorage::HasBeenDestroyed();
+}
+
+}  // namespace base