Avi Drissman | e4622aa | 2022-09-08 20:36:06 | [diff] [blame] | 1 | // Copyright 2014 The Chromium Authors |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
avi | 9b6f4293 | 2015-12-26 22:15:14 | [diff] [blame] | 5 | #include <stddef.h> |
| 6 | #include <stdint.h> |
| 7 | |
Peter Boström | fd85123 | 2021-03-31 17:05:33 | [diff] [blame] | 8 | #include <memory> |
| 9 | |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 10 | #include "base/format_macros.h" |
Avi Drissman | 63e1f99 | 2023-01-13 18:54:43 | [diff] [blame] | 11 | #include "base/functional/bind.h" |
| 12 | #include "base/functional/callback_helpers.h" |
dcheng | 093de9b | 2016-04-04 21:25:51 | [diff] [blame] | 13 | #include "base/memory/ptr_util.h" |
Carlos Caballero | dd8bf7b04 | 2019-07-30 14:14:15 | [diff] [blame] | 14 | #include "base/message_loop/message_pump_type.h" |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 15 | #include "base/strings/stringprintf.h" |
| 16 | #include "base/synchronization/condition_variable.h" |
| 17 | #include "base/synchronization/lock.h" |
| 18 | #include "base/synchronization/waitable_event.h" |
Carlos Caballero | b25fe847 | 2020-07-17 10:27:17 | [diff] [blame] | 19 | #include "base/task/current_thread.h" |
Carlos Caballero | 14712af9 | 2019-04-17 16:13:01 | [diff] [blame] | 20 | #include "base/task/sequence_manager/sequence_manager_impl.h" |
Patrick Monette | 643cdf6 | 2021-10-15 19:13:42 | [diff] [blame] | 21 | #include "base/task/single_thread_task_runner.h" |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 22 | #include "base/threading/thread.h" |
| 23 | #include "base/time/time.h" |
| 24 | #include "build/build_config.h" |
| 25 | #include "testing/gtest/include/gtest/gtest.h" |
Brian Sheedy | f7adb4b | 2019-12-19 02:23:18 | [diff] [blame] | 26 | #include "testing/perf/perf_result_reporter.h" |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 27 | |
Xiaohan Wang | 29b5fdd | 2022-01-15 19:10:02 | [diff] [blame] | 28 | #if BUILDFLAG(IS_ANDROID) |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 29 | #include "base/android/java_handler_thread.h" |
| 30 | #endif |
| 31 | |
| 32 | namespace base { |
Alex Clarke | e1cc1bb | 2019-06-06 17:24:25 | [diff] [blame] | 33 | namespace { |
| 34 | |
Brian Sheedy | f7adb4b | 2019-12-19 02:23:18 | [diff] [blame] | 35 | constexpr char kMetricPrefixScheduleWork[] = "ScheduleWork."; |
| 36 | constexpr char kMetricMinBatchTime[] = "min_batch_time_per_task"; |
| 37 | constexpr char kMetricMaxBatchTime[] = "max_batch_time_per_task"; |
| 38 | constexpr char kMetricTotalTime[] = "total_time_per_task"; |
| 39 | constexpr char kMetricThreadTime[] = "thread_time_per_task"; |
| 40 | |
| 41 | perf_test::PerfResultReporter SetUpReporter(const std::string& story_name) { |
| 42 | perf_test::PerfResultReporter reporter(kMetricPrefixScheduleWork, story_name); |
| 43 | reporter.RegisterImportantMetric(kMetricMinBatchTime, "us"); |
| 44 | reporter.RegisterImportantMetric(kMetricMaxBatchTime, "us"); |
| 45 | reporter.RegisterImportantMetric(kMetricTotalTime, "us"); |
| 46 | reporter.RegisterImportantMetric(kMetricThreadTime, "us"); |
| 47 | return reporter; |
| 48 | } |
| 49 | |
Xiaohan Wang | 29b5fdd | 2022-01-15 19:10:02 | [diff] [blame] | 50 | #if BUILDFLAG(IS_ANDROID) |
Alex Clarke | e1cc1bb | 2019-06-06 17:24:25 | [diff] [blame] | 51 | class JavaHandlerThreadForTest : public android::JavaHandlerThread { |
| 52 | public: |
| 53 | explicit JavaHandlerThreadForTest(const char* name) |
Zhibo Wang | d9e4a00 | 2022-07-07 04:34:59 | [diff] [blame] | 54 | : android::JavaHandlerThread(name, base::ThreadType::kDefault) {} |
Alex Clarke | e1cc1bb | 2019-06-06 17:24:25 | [diff] [blame] | 55 | |
Gabriel Charette | 35f2625 | 2019-08-12 12:01:20 | [diff] [blame] | 56 | using android::JavaHandlerThread::state; |
| 57 | using android::JavaHandlerThread::State; |
Alex Clarke | e1cc1bb | 2019-06-06 17:24:25 | [diff] [blame] | 58 | }; |
| 59 | #endif |
| 60 | |
| 61 | } // namespace |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 62 | |
| 63 | class ScheduleWorkTest : public testing::Test { |
| 64 | public: |
Peter Kasting | 6218bbad | 2025-01-10 11:26:40 | [diff] [blame] | 65 | ScheduleWorkTest() = default; |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 66 | |
fdoray | dc2a659 | 2015-10-15 03:46:40 | [diff] [blame] | 67 | void SetUp() override { |
Peter Kasting | 134ef9af | 2024-12-28 02:30:09 | [diff] [blame] | 68 | if (base::ThreadTicks::IsSupported()) { |
fdoray | dc2a659 | 2015-10-15 03:46:40 | [diff] [blame] | 69 | base::ThreadTicks::WaitUntilInitialized(); |
Peter Kasting | 134ef9af | 2024-12-28 02:30:09 | [diff] [blame] | 70 | } |
fdoray | dc2a659 | 2015-10-15 03:46:40 | [diff] [blame] | 71 | } |
| 72 | |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 73 | void Increment(uint64_t amount) { counter_ += amount; } |
| 74 | |
| 75 | void Schedule(int index) { |
charliea | 3be83970 | 2015-01-26 17:35:41 | [diff] [blame] | 76 | base::TimeTicks start = base::TimeTicks::Now(); |
miu | 1ab506a | 2015-05-29 23:57:12 | [diff] [blame] | 77 | base::ThreadTicks thread_start; |
Peter Kasting | 134ef9af | 2024-12-28 02:30:09 | [diff] [blame] | 78 | if (ThreadTicks::IsSupported()) { |
miu | 1ab506a | 2015-05-29 23:57:12 | [diff] [blame] | 79 | thread_start = base::ThreadTicks::Now(); |
Peter Kasting | 134ef9af | 2024-12-28 02:30:09 | [diff] [blame] | 80 | } |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 81 | base::TimeDelta minimum = base::TimeDelta::Max(); |
| 82 | base::TimeDelta maximum = base::TimeDelta(); |
| 83 | base::TimeTicks now, lastnow = start; |
| 84 | uint64_t schedule_calls = 0u; |
| 85 | do { |
| 86 | for (size_t i = 0; i < kBatchSize; ++i) { |
Alex Clarke | 00c5639 | 2019-02-15 20:22:56 | [diff] [blame] | 87 | target_message_loop_base()->GetMessagePump()->ScheduleWork(); |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 88 | schedule_calls++; |
| 89 | } |
charliea | 3be83970 | 2015-01-26 17:35:41 | [diff] [blame] | 90 | now = base::TimeTicks::Now(); |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 91 | base::TimeDelta laptime = now - lastnow; |
| 92 | lastnow = now; |
| 93 | minimum = std::min(minimum, laptime); |
| 94 | maximum = std::max(maximum, laptime); |
Peter Kasting | e5a38ed | 2021-10-02 03:06:35 | [diff] [blame] | 95 | } while (now - start < base::Seconds(kTargetTimeSec)); |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 96 | |
| 97 | scheduling_times_[index] = now - start; |
Peter Kasting | 134ef9af | 2024-12-28 02:30:09 | [diff] [blame] | 98 | if (ThreadTicks::IsSupported()) { |
| 99 | scheduling_thread_times_[index] = base::ThreadTicks::Now() - thread_start; |
| 100 | } |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 101 | min_batch_times_[index] = minimum; |
| 102 | max_batch_times_[index] = maximum; |
Alex Clarke | 00c5639 | 2019-02-15 20:22:56 | [diff] [blame] | 103 | target_message_loop_base()->GetTaskRunner()->PostTask( |
tzik | 92b7a42 | 2017-04-11 15:00:44 | [diff] [blame] | 104 | FROM_HERE, base::BindOnce(&ScheduleWorkTest::Increment, |
| 105 | base::Unretained(this), schedule_calls)); |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 106 | } |
| 107 | |
Carlos Caballero | dd8bf7b04 | 2019-07-30 14:14:15 | [diff] [blame] | 108 | void ScheduleWork(MessagePumpType target_type, int num_scheduling_threads) { |
Xiaohan Wang | 29b5fdd | 2022-01-15 19:10:02 | [diff] [blame] | 109 | #if BUILDFLAG(IS_ANDROID) |
Carlos Caballero | dd8bf7b04 | 2019-07-30 14:14:15 | [diff] [blame] | 110 | if (target_type == MessagePumpType::JAVA) { |
Peter Boström | 08e7ed8 | 2021-04-19 17:49:59 | [diff] [blame] | 111 | java_thread_ = std::make_unique<JavaHandlerThreadForTest>("target"); |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 112 | java_thread_->Start(); |
| 113 | } else |
| 114 | #endif |
| 115 | { |
Peter Boström | fd85123 | 2021-03-31 17:05:33 | [diff] [blame] | 116 | target_ = std::make_unique<Thread>("test"); |
Alex Clarke | 636d6b6 | 2019-02-22 01:39:04 | [diff] [blame] | 117 | |
| 118 | Thread::Options options(target_type, 0u); |
Carlos Caballero | 6a2f39b | 2019-09-25 08:03:10 | [diff] [blame] | 119 | options.message_pump_type = target_type; |
Olivier Li | d68d079 | 2021-05-17 20:51:41 | [diff] [blame] | 120 | target_->StartWithOptions(std::move(options)); |
amistry | 7fc519fa | 2015-08-10 23:50:44 | [diff] [blame] | 121 | |
| 122 | // Without this, it's possible for the scheduling threads to start and run |
| 123 | // before the target thread. In this case, the scheduling threads will |
| 124 | // call target_message_loop()->ScheduleWork(), which dereferences the |
| 125 | // loop's message pump, which is only created after the target thread has |
| 126 | // finished starting. |
| 127 | target_->WaitUntilThreadStarted(); |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 128 | } |
| 129 | |
dcheng | 093de9b | 2016-04-04 21:25:51 | [diff] [blame] | 130 | std::vector<std::unique_ptr<Thread>> scheduling_threads; |
Peter Boström | fd85123 | 2021-03-31 17:05:33 | [diff] [blame] | 131 | scheduling_times_ = |
| 132 | std::make_unique<base::TimeDelta[]>(num_scheduling_threads); |
| 133 | scheduling_thread_times_ = |
| 134 | std::make_unique<base::TimeDelta[]>(num_scheduling_threads); |
| 135 | min_batch_times_ = |
| 136 | std::make_unique<base::TimeDelta[]>(num_scheduling_threads); |
| 137 | max_batch_times_ = |
| 138 | std::make_unique<base::TimeDelta[]>(num_scheduling_threads); |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 139 | |
| 140 | for (int i = 0; i < num_scheduling_threads; ++i) { |
Jeremy Roman | 9532f25 | 2017-08-16 23:27:24 | [diff] [blame] | 141 | scheduling_threads.push_back(std::make_unique<Thread>("posting thread")); |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 142 | scheduling_threads[i]->Start(); |
| 143 | } |
| 144 | |
| 145 | for (int i = 0; i < num_scheduling_threads; ++i) { |
fdoray | 6ef45cf | 2016-08-25 15:36:37 | [diff] [blame] | 146 | scheduling_threads[i]->task_runner()->PostTask( |
tzik | 92b7a42 | 2017-04-11 15:00:44 | [diff] [blame] | 147 | FROM_HERE, base::BindOnce(&ScheduleWorkTest::Schedule, |
| 148 | base::Unretained(this), i)); |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 149 | } |
| 150 | |
| 151 | for (int i = 0; i < num_scheduling_threads; ++i) { |
| 152 | scheduling_threads[i]->Stop(); |
| 153 | } |
Xiaohan Wang | 29b5fdd | 2022-01-15 19:10:02 | [diff] [blame] | 154 | #if BUILDFLAG(IS_ANDROID) |
Carlos Caballero | dd8bf7b04 | 2019-07-30 14:14:15 | [diff] [blame] | 155 | if (target_type == MessagePumpType::JAVA) { |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 156 | java_thread_->Stop(); |
| 157 | java_thread_.reset(); |
| 158 | } else |
| 159 | #endif |
| 160 | { |
| 161 | target_->Stop(); |
| 162 | target_.reset(); |
| 163 | } |
| 164 | base::TimeDelta total_time; |
| 165 | base::TimeDelta total_thread_time; |
| 166 | base::TimeDelta min_batch_time = base::TimeDelta::Max(); |
| 167 | base::TimeDelta max_batch_time = base::TimeDelta(); |
| 168 | for (int i = 0; i < num_scheduling_threads; ++i) { |
| 169 | total_time += scheduling_times_[i]; |
| 170 | total_thread_time += scheduling_thread_times_[i]; |
| 171 | min_batch_time = std::min(min_batch_time, min_batch_times_[i]); |
| 172 | max_batch_time = std::max(max_batch_time, max_batch_times_[i]); |
| 173 | } |
Brian Sheedy | f7adb4b | 2019-12-19 02:23:18 | [diff] [blame] | 174 | |
| 175 | std::string story_name = StringPrintf( |
| 176 | "%s_pump_from_%d_threads", |
Carlos Caballero | dd8bf7b04 | 2019-07-30 14:14:15 | [diff] [blame] | 177 | target_type == MessagePumpType::IO |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 178 | ? "io" |
Brian Sheedy | f7adb4b | 2019-12-19 02:23:18 | [diff] [blame] | 179 | : (target_type == MessagePumpType::UI ? "ui" : "default"), |
| 180 | num_scheduling_threads); |
| 181 | auto reporter = SetUpReporter(story_name); |
| 182 | reporter.AddResult(kMetricMinBatchTime, total_time.InMicroseconds() / |
| 183 | static_cast<double>(counter_)); |
| 184 | reporter.AddResult( |
| 185 | kMetricMaxBatchTime, |
| 186 | max_batch_time.InMicroseconds() / static_cast<double>(kBatchSize)); |
| 187 | reporter.AddResult(kMetricTotalTime, total_time.InMicroseconds() / |
| 188 | static_cast<double>(counter_)); |
miu | 1ab506a | 2015-05-29 23:57:12 | [diff] [blame] | 189 | if (ThreadTicks::IsSupported()) { |
Brian Sheedy | f7adb4b | 2019-12-19 02:23:18 | [diff] [blame] | 190 | reporter.AddResult(kMetricThreadTime, total_thread_time.InMicroseconds() / |
| 191 | static_cast<double>(counter_)); |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 192 | } |
| 193 | } |
| 194 | |
Carlos Caballero | 14712af9 | 2019-04-17 16:13:01 | [diff] [blame] | 195 | sequence_manager::internal::SequenceManagerImpl* target_message_loop_base() { |
Xiaohan Wang | 29b5fdd | 2022-01-15 19:10:02 | [diff] [blame] | 196 | #if BUILDFLAG(IS_ANDROID) |
Alex Clarke | e1cc1bb | 2019-06-06 17:24:25 | [diff] [blame] | 197 | if (java_thread_) { |
| 198 | return static_cast<sequence_manager::internal::SequenceManagerImpl*>( |
Gabriel Charette | 35f2625 | 2019-08-12 12:01:20 | [diff] [blame] | 199 | java_thread_->state()->sequence_manager.get()); |
Alex Clarke | e1cc1bb | 2019-06-06 17:24:25 | [diff] [blame] | 200 | } |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 201 | #endif |
Carlos Caballero | b25fe847 | 2020-07-17 10:27:17 | [diff] [blame] | 202 | return CurrentThread::Get()->GetCurrentSequenceManagerImpl(); |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 203 | } |
| 204 | |
| 205 | private: |
Alex Clarke | 636d6b6 | 2019-02-22 01:39:04 | [diff] [blame] | 206 | std::unique_ptr<Thread> target_; |
Xiaohan Wang | 29b5fdd | 2022-01-15 19:10:02 | [diff] [blame] | 207 | #if BUILDFLAG(IS_ANDROID) |
Alex Clarke | e1cc1bb | 2019-06-06 17:24:25 | [diff] [blame] | 208 | std::unique_ptr<JavaHandlerThreadForTest> java_thread_; |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 209 | #endif |
dcheng | 093de9b | 2016-04-04 21:25:51 | [diff] [blame] | 210 | std::unique_ptr<base::TimeDelta[]> scheduling_times_; |
| 211 | std::unique_ptr<base::TimeDelta[]> scheduling_thread_times_; |
| 212 | std::unique_ptr<base::TimeDelta[]> min_batch_times_; |
| 213 | std::unique_ptr<base::TimeDelta[]> max_batch_times_; |
Peter Kasting | 811504a7 | 2025-01-09 03:18:50 | [diff] [blame] | 214 | uint64_t counter_ = 0; |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 215 | |
| 216 | static const size_t kTargetTimeSec = 5; |
| 217 | static const size_t kBatchSize = 1000; |
| 218 | }; |
| 219 | |
| 220 | TEST_F(ScheduleWorkTest, ThreadTimeToIOFromOneThread) { |
Carlos Caballero | dd8bf7b04 | 2019-07-30 14:14:15 | [diff] [blame] | 221 | ScheduleWork(MessagePumpType::IO, 1); |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 222 | } |
| 223 | |
| 224 | TEST_F(ScheduleWorkTest, ThreadTimeToIOFromTwoThreads) { |
Carlos Caballero | dd8bf7b04 | 2019-07-30 14:14:15 | [diff] [blame] | 225 | ScheduleWork(MessagePumpType::IO, 2); |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 226 | } |
| 227 | |
| 228 | TEST_F(ScheduleWorkTest, ThreadTimeToIOFromFourThreads) { |
Carlos Caballero | dd8bf7b04 | 2019-07-30 14:14:15 | [diff] [blame] | 229 | ScheduleWork(MessagePumpType::IO, 4); |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 230 | } |
| 231 | |
| 232 | TEST_F(ScheduleWorkTest, ThreadTimeToUIFromOneThread) { |
Carlos Caballero | dd8bf7b04 | 2019-07-30 14:14:15 | [diff] [blame] | 233 | ScheduleWork(MessagePumpType::UI, 1); |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 234 | } |
| 235 | |
| 236 | TEST_F(ScheduleWorkTest, ThreadTimeToUIFromTwoThreads) { |
Carlos Caballero | dd8bf7b04 | 2019-07-30 14:14:15 | [diff] [blame] | 237 | ScheduleWork(MessagePumpType::UI, 2); |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 238 | } |
| 239 | |
| 240 | TEST_F(ScheduleWorkTest, ThreadTimeToUIFromFourThreads) { |
Carlos Caballero | dd8bf7b04 | 2019-07-30 14:14:15 | [diff] [blame] | 241 | ScheduleWork(MessagePumpType::UI, 4); |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 242 | } |
| 243 | |
| 244 | TEST_F(ScheduleWorkTest, ThreadTimeToDefaultFromOneThread) { |
Carlos Caballero | dd8bf7b04 | 2019-07-30 14:14:15 | [diff] [blame] | 245 | ScheduleWork(MessagePumpType::DEFAULT, 1); |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 246 | } |
| 247 | |
| 248 | TEST_F(ScheduleWorkTest, ThreadTimeToDefaultFromTwoThreads) { |
Carlos Caballero | dd8bf7b04 | 2019-07-30 14:14:15 | [diff] [blame] | 249 | ScheduleWork(MessagePumpType::DEFAULT, 2); |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 250 | } |
| 251 | |
| 252 | TEST_F(ScheduleWorkTest, ThreadTimeToDefaultFromFourThreads) { |
Carlos Caballero | dd8bf7b04 | 2019-07-30 14:14:15 | [diff] [blame] | 253 | ScheduleWork(MessagePumpType::DEFAULT, 4); |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 254 | } |
| 255 | |
Xiaohan Wang | 29b5fdd | 2022-01-15 19:10:02 | [diff] [blame] | 256 | #if BUILDFLAG(IS_ANDROID) |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 257 | TEST_F(ScheduleWorkTest, ThreadTimeToJavaFromOneThread) { |
Carlos Caballero | dd8bf7b04 | 2019-07-30 14:14:15 | [diff] [blame] | 258 | ScheduleWork(MessagePumpType::JAVA, 1); |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 259 | } |
| 260 | |
| 261 | TEST_F(ScheduleWorkTest, ThreadTimeToJavaFromTwoThreads) { |
Carlos Caballero | dd8bf7b04 | 2019-07-30 14:14:15 | [diff] [blame] | 262 | ScheduleWork(MessagePumpType::JAVA, 2); |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 263 | } |
| 264 | |
| 265 | TEST_F(ScheduleWorkTest, ThreadTimeToJavaFromFourThreads) { |
Carlos Caballero | dd8bf7b04 | 2019-07-30 14:14:15 | [diff] [blame] | 266 | ScheduleWork(MessagePumpType::JAVA, 4); |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 267 | } |
| 268 | #endif |
| 269 | |
jamesr | 2e146d7 | 2014-09-29 21:12:44 | [diff] [blame] | 270 | } // namespace base |