1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
  100
  101


base / threading / thread_checker_impl.h [blame]

// Copyright 2011 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef BASE_THREADING_THREAD_CHECKER_IMPL_H_
#define BASE_THREADING_THREAD_CHECKER_IMPL_H_

#include <memory>

#include "base/base_export.h"
#include "base/sequence_token.h"
#include "base/synchronization/lock.h"
#include "base/thread_annotations.h"
#include "base/threading/platform_thread_ref.h"

namespace base {
namespace debug {
class StackTrace;
}

class SequenceCheckerImpl;

// Real implementation of ThreadChecker, for use in debug mode, or for temporary
// use in release mode (e.g. to CHECK on a threading issue seen only in the
// wild).
//
// Note: You should almost always use the ThreadChecker class to get the right
// version for your build configuration.
// Note: This is only a check, not a "lock". It is marked "LOCKABLE" only in
// order to support thread_annotations.h.
class LOCKABLE BASE_EXPORT ThreadCheckerImpl {
 public:
  ThreadCheckerImpl();
  ~ThreadCheckerImpl();

  // Allow move construct/assign. This must be called on |other|'s associated
  // thread and assignment can only be made into a ThreadCheckerImpl which is
  // detached or already associated with the current thread. This isn't
  // thread-safe (|this| and |other| shouldn't be in use while this move is
  // performed). If the assignment was legal, the resulting ThreadCheckerImpl
  // will be bound to the current thread and |other| will be detached.
  ThreadCheckerImpl(ThreadCheckerImpl&& other);
  ThreadCheckerImpl& operator=(ThreadCheckerImpl&& other);

  // On returning false, if logging is enabled with EnableStackLogging() and
  // `out_bound_at` is not null, this method allocates a StackTrace and returns
  // it in the out-parameter, storing inside it the stack from where the failing
  // ThreadChecker was bound to its thread.
  [[nodiscard]] bool CalledOnValidThread(
      std::unique_ptr<debug::StackTrace>* out_bound_at = nullptr) const
      LOCKS_EXCLUDED(lock_);

  // Changes the thread that is checked for in CalledOnValidThread.  This may
  // be useful when an object may be created on one thread and then used
  // exclusively on another thread.
  void DetachFromThread() LOCKS_EXCLUDED(lock_);

 private:
  friend class SequenceCheckerImpl;

  // Private because it's only called by
  // `SequenceCheckerImpl::EnableStackLogging()`.
  static void EnableStackLogging();

  // Returns ownership of a pointer to StackTrace where the ThreadCheckerImpl
  // was bound for debug logs, or nullptr if such logging was not enabled at
  // the time.
  std::unique_ptr<debug::StackTrace> GetBoundAt() const
      EXCLUSIVE_LOCKS_REQUIRED(lock_);

  void EnsureAssigned() const EXCLUSIVE_LOCKS_REQUIRED(lock_);

  // Members are mutable so that CalledOnValidThread() can set them.

  // Synchronizes access to all members.
  mutable base::Lock lock_;

  // Stack from which this was bound (set if `EnableStackLogging()` was called).
  mutable std::unique_ptr<debug::StackTrace> bound_at_ GUARDED_BY(lock_);

  // Thread on which CalledOnValidThread() may return true.
  mutable PlatformThreadRef thread_ref_ GUARDED_BY(lock_);

  // TaskToken for which CalledOnValidThread() always returns true. This allows
  // CalledOnValidThread() to return true when called multiple times from the
  // same task, even if it's not running in a single-threaded context itself
  // (allowing usage of ThreadChecker objects on the stack in the scope of one-
  // off tasks). Note: CalledOnValidThread() may return true even if the current
  // TaskToken is not equal to this.
  mutable internal::TaskToken task_token_ GUARDED_BY(lock_);

  // SequenceToken for which CalledOnValidThread() may return true. Used to
  // ensure that CalledOnValidThread() doesn't return true for ThreadPool
  // tasks that happen to run on the same thread but weren't posted to the same
  // SingleThreadTaskRunner.
  mutable internal::SequenceToken sequence_token_ GUARDED_BY(lock_);
};

}  // namespace base

#endif  // BASE_THREADING_THREAD_CHECKER_IMPL_H_