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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef REMOTING_BASE_AUTO_THREAD_H_
#define REMOTING_BASE_AUTO_THREAD_H_
#include <string>
#include "base/functional/callback_forward.h"
#include "base/memory/raw_ptr.h"
#include "base/message_loop/message_pump_type.h"
#include "base/task/sequenced_task_runner.h"
#include "base/threading/platform_thread.h"
#include "base/threading/thread_checker.h"
#include "build/build_config.h"
#include "remoting/base/auto_thread_task_runner.h"
namespace remoting {
// Thread implementation that runs a MessageLoop on a new thread, and manages
// the lifetime of the MessageLoop and thread by tracking references to the
// thread's TaskRunner. The caller passes the thread's TaskRunner to each
// object that needs to run code on the thread, and when no references to the
// TaskRunner remain, the thread will exit. When the caller destroys this
// object they will be blocked until the thread exits.
// All pending tasks queued on the thread's message loop will run to completion
// before the thread is terminated.
//
// After the thread is stopped, the destruction sequence is:
//
// (1) Thread::CleanUp()
// (2) MessageLoop::~MessageLoop
// (3.b) CurrentThread::DestructionObserver::WillDestroyCurrentMessageLoop
class AutoThread : base::PlatformThread::Delegate {
public:
// Create an AutoThread with the specified message-loop |type| and |name|.
// The supplied AutoThreadTaskRunner will be used to join and delete the
// new thread when no references to it remain.
// |pre_init_callback| will be run at the beginning of ThreadMain(), before
// the message pump is created. This may be used to do initialization work
// before any resource is open on the thread, such as calling
// SetThreadDesktop() on a Windows UI thread.
static scoped_refptr<AutoThreadTaskRunner> CreateWithPreInitCallback(
const char* name,
scoped_refptr<base::SequencedTaskRunner> joiner,
base::MessagePumpType pump_type,
base::OnceClosure pre_init_callback);
static scoped_refptr<AutoThreadTaskRunner> CreateWithType(
const char* name,
scoped_refptr<base::SequencedTaskRunner> joiner,
base::MessagePumpType type);
static scoped_refptr<AutoThreadTaskRunner> Create(
const char* name,
scoped_refptr<base::SequencedTaskRunner> joiner);
#if BUILDFLAG(IS_WIN)
// Create an AutoThread initialized for COM. |com_init_type| specifies the
// type of COM apartment to initialize.
enum ComInitType { COM_INIT_NONE, COM_INIT_STA, COM_INIT_MTA };
static scoped_refptr<AutoThreadTaskRunner> CreateWithLoopAndComInitTypes(
const char* name,
scoped_refptr<base::SequencedTaskRunner> joiner,
base::MessagePumpType pump_type,
ComInitType com_init_type);
#endif
// Construct the AutoThread. |name| identifies the thread for debugging.
explicit AutoThread(const char* name);
AutoThread(const AutoThread&) = delete;
AutoThread& operator=(const AutoThread&) = delete;
// Waits for the thread to exit, and then destroys it.
~AutoThread() override;
// Starts the thread, running the specified type of MessageLoop. Returns
// an AutoThreadTaskRunner through which tasks may be posted to the thread
// if successful, or NULL on failure.
//
// Note: This function can't be called on Windows with the loader lock held;
// i.e. during a DllMain, global object construction or destruction, atexit()
// callback.
//
// NOTE: You must not call this MessageLoop's Quit method directly. The
// thread will exit when no references to the TaskRunner remain.
scoped_refptr<AutoThreadTaskRunner> StartWithType(base::MessagePumpType type);
#if BUILDFLAG(IS_WIN)
// Configures the thread to initialize the specified COM apartment type.
// SetComInitType() must be called before Start().
void SetComInitType(ComInitType com_init_type);
#endif
private:
AutoThread(const char* name, scoped_refptr<base::SequencedTaskRunner> joiner);
void QuitThread(base::OnceClosure quit_when_idle_closure);
void JoinAndDeleteThread();
// base::PlatformThread::Delegate methods:
void ThreadMain() override;
// Used to pass data to ThreadMain.
struct StartupData;
raw_ptr<StartupData> startup_data_;
base::OnceClosure pre_init_callback_;
#if BUILDFLAG(IS_WIN)
// Specifies which kind of COM apartment to initialize, if any.
ComInitType com_init_type_;
#endif
// The thread's handle.
base::PlatformThreadHandle thread_;
// The name of the thread. Used for debugging purposes.
std::string name_;
// Flag used to indicate whether MessageLoop was quit properly.
// This allows us to detect premature exit via MessageLoop::QuitWhenIdle().
bool was_quit_properly_;
// Task runner to post a task to to join & delete this thread.
scoped_refptr<base::SequencedTaskRunner> joiner_;
// Verifies that QuitThread() is called on the same thread as ThreadMain().
base::ThreadChecker thread_checker_;
};
} // namespace remoting
#endif // REMOTING_BASE_AUTO_THREAD_H_
|
