OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/message_loop/message_pump_libevent.h" | 5 #include "base/message_loop/message_pump_libevent.h" |
6 | 6 |
7 #include <unistd.h> | 7 #include <unistd.h> |
8 | 8 |
9 #include "base/bind.h" | 9 #include "base/bind.h" |
10 #include "base/message_loop/message_loop.h" | 10 #include "base/message_loop/message_loop.h" |
11 #include "base/posix/eintr_wrapper.h" | 11 #include "base/posix/eintr_wrapper.h" |
12 #include "base/run_loop.h" | 12 #include "base/run_loop.h" |
13 #include "base/threading/thread.h" | 13 #include "base/threading/thread.h" |
14 #include "testing/gtest/include/gtest/gtest.h" | 14 #include "testing/gtest/include/gtest/gtest.h" |
15 #include "third_party/libevent/event.h" | 15 #include "third_party/libevent/event.h" |
16 | 16 |
17 namespace base { | 17 namespace base { |
18 | 18 |
19 class MessagePumpLibeventTest : public testing::Test { | 19 class MessagePumpLibeventTest : public testing::Test { |
20 protected: | 20 protected: |
21 MessagePumpLibeventTest() | 21 MessagePumpLibeventTest() |
22 : ui_loop_(MessageLoop::TYPE_UI), | 22 : ui_loop_(MessageLoop::TYPE_UI), |
23 io_thread_("MessagePumpLibeventTestIOThread") {} | 23 io_thread_("MessagePumpLibeventTestIOThread") {} |
24 virtual ~MessagePumpLibeventTest() {} | 24 virtual ~MessagePumpLibeventTest() {} |
25 | 25 |
26 virtual void SetUp() OVERRIDE { | 26 virtual void SetUp() override { |
27 Thread::Options options(MessageLoop::TYPE_IO, 0); | 27 Thread::Options options(MessageLoop::TYPE_IO, 0); |
28 ASSERT_TRUE(io_thread_.StartWithOptions(options)); | 28 ASSERT_TRUE(io_thread_.StartWithOptions(options)); |
29 ASSERT_EQ(MessageLoop::TYPE_IO, io_thread_.message_loop()->type()); | 29 ASSERT_EQ(MessageLoop::TYPE_IO, io_thread_.message_loop()->type()); |
30 int ret = pipe(pipefds_); | 30 int ret = pipe(pipefds_); |
31 ASSERT_EQ(0, ret); | 31 ASSERT_EQ(0, ret); |
32 } | 32 } |
33 | 33 |
34 virtual void TearDown() OVERRIDE { | 34 virtual void TearDown() override { |
35 if (IGNORE_EINTR(close(pipefds_[0])) < 0) | 35 if (IGNORE_EINTR(close(pipefds_[0])) < 0) |
36 PLOG(ERROR) << "close"; | 36 PLOG(ERROR) << "close"; |
37 if (IGNORE_EINTR(close(pipefds_[1])) < 0) | 37 if (IGNORE_EINTR(close(pipefds_[1])) < 0) |
38 PLOG(ERROR) << "close"; | 38 PLOG(ERROR) << "close"; |
39 } | 39 } |
40 | 40 |
41 MessageLoop* ui_loop() { return &ui_loop_; } | 41 MessageLoop* ui_loop() { return &ui_loop_; } |
42 MessageLoopForIO* io_loop() const { | 42 MessageLoopForIO* io_loop() const { |
43 return static_cast<MessageLoopForIO*>(io_thread_.message_loop()); | 43 return static_cast<MessageLoopForIO*>(io_thread_.message_loop()); |
44 } | 44 } |
(...skipping 13 matching lines...) Expand all Loading... |
58 | 58 |
59 namespace { | 59 namespace { |
60 | 60 |
61 // Concrete implementation of MessagePumpLibevent::Watcher that does | 61 // Concrete implementation of MessagePumpLibevent::Watcher that does |
62 // nothing useful. | 62 // nothing useful. |
63 class StupidWatcher : public MessagePumpLibevent::Watcher { | 63 class StupidWatcher : public MessagePumpLibevent::Watcher { |
64 public: | 64 public: |
65 virtual ~StupidWatcher() {} | 65 virtual ~StupidWatcher() {} |
66 | 66 |
67 // base:MessagePumpLibevent::Watcher interface | 67 // base:MessagePumpLibevent::Watcher interface |
68 virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE {} | 68 virtual void OnFileCanReadWithoutBlocking(int fd) override {} |
69 virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE {} | 69 virtual void OnFileCanWriteWithoutBlocking(int fd) override {} |
70 }; | 70 }; |
71 | 71 |
72 #if GTEST_HAS_DEATH_TEST && !defined(NDEBUG) | 72 #if GTEST_HAS_DEATH_TEST && !defined(NDEBUG) |
73 | 73 |
74 // Test to make sure that we catch calling WatchFileDescriptor off of the | 74 // Test to make sure that we catch calling WatchFileDescriptor off of the |
75 // wrong thread. | 75 // wrong thread. |
76 TEST_F(MessagePumpLibeventTest, TestWatchingFromBadThread) { | 76 TEST_F(MessagePumpLibeventTest, TestWatchingFromBadThread) { |
77 MessagePumpLibevent::FileDescriptorWatcher watcher; | 77 MessagePumpLibevent::FileDescriptorWatcher watcher; |
78 StupidWatcher delegate; | 78 StupidWatcher delegate; |
79 | 79 |
(...skipping 13 matching lines...) Expand all Loading... |
93 | 93 |
94 class BaseWatcher : public MessagePumpLibevent::Watcher { | 94 class BaseWatcher : public MessagePumpLibevent::Watcher { |
95 public: | 95 public: |
96 explicit BaseWatcher(MessagePumpLibevent::FileDescriptorWatcher* controller) | 96 explicit BaseWatcher(MessagePumpLibevent::FileDescriptorWatcher* controller) |
97 : controller_(controller) { | 97 : controller_(controller) { |
98 DCHECK(controller_); | 98 DCHECK(controller_); |
99 } | 99 } |
100 virtual ~BaseWatcher() {} | 100 virtual ~BaseWatcher() {} |
101 | 101 |
102 // base:MessagePumpLibevent::Watcher interface | 102 // base:MessagePumpLibevent::Watcher interface |
103 virtual void OnFileCanReadWithoutBlocking(int /* fd */) OVERRIDE { | 103 virtual void OnFileCanReadWithoutBlocking(int /* fd */) override { |
104 NOTREACHED(); | 104 NOTREACHED(); |
105 } | 105 } |
106 | 106 |
107 virtual void OnFileCanWriteWithoutBlocking(int /* fd */) OVERRIDE { | 107 virtual void OnFileCanWriteWithoutBlocking(int /* fd */) override { |
108 NOTREACHED(); | 108 NOTREACHED(); |
109 } | 109 } |
110 | 110 |
111 protected: | 111 protected: |
112 MessagePumpLibevent::FileDescriptorWatcher* controller_; | 112 MessagePumpLibevent::FileDescriptorWatcher* controller_; |
113 }; | 113 }; |
114 | 114 |
115 class DeleteWatcher : public BaseWatcher { | 115 class DeleteWatcher : public BaseWatcher { |
116 public: | 116 public: |
117 explicit DeleteWatcher( | 117 explicit DeleteWatcher( |
118 MessagePumpLibevent::FileDescriptorWatcher* controller) | 118 MessagePumpLibevent::FileDescriptorWatcher* controller) |
119 : BaseWatcher(controller) {} | 119 : BaseWatcher(controller) {} |
120 | 120 |
121 virtual ~DeleteWatcher() { | 121 virtual ~DeleteWatcher() { |
122 DCHECK(!controller_); | 122 DCHECK(!controller_); |
123 } | 123 } |
124 | 124 |
125 virtual void OnFileCanWriteWithoutBlocking(int /* fd */) OVERRIDE { | 125 virtual void OnFileCanWriteWithoutBlocking(int /* fd */) override { |
126 DCHECK(controller_); | 126 DCHECK(controller_); |
127 delete controller_; | 127 delete controller_; |
128 controller_ = NULL; | 128 controller_ = NULL; |
129 } | 129 } |
130 }; | 130 }; |
131 | 131 |
132 TEST_F(MessagePumpLibeventTest, DeleteWatcher) { | 132 TEST_F(MessagePumpLibeventTest, DeleteWatcher) { |
133 scoped_ptr<MessagePumpLibevent> pump(new MessagePumpLibevent); | 133 scoped_ptr<MessagePumpLibevent> pump(new MessagePumpLibevent); |
134 MessagePumpLibevent::FileDescriptorWatcher* watcher = | 134 MessagePumpLibevent::FileDescriptorWatcher* watcher = |
135 new MessagePumpLibevent::FileDescriptorWatcher; | 135 new MessagePumpLibevent::FileDescriptorWatcher; |
136 DeleteWatcher delegate(watcher); | 136 DeleteWatcher delegate(watcher); |
137 pump->WatchFileDescriptor(pipefds_[1], | 137 pump->WatchFileDescriptor(pipefds_[1], |
138 false, MessagePumpLibevent::WATCH_READ_WRITE, watcher, &delegate); | 138 false, MessagePumpLibevent::WATCH_READ_WRITE, watcher, &delegate); |
139 | 139 |
140 // Spoof a libevent notification. | 140 // Spoof a libevent notification. |
141 OnLibeventNotification(pump.get(), watcher); | 141 OnLibeventNotification(pump.get(), watcher); |
142 } | 142 } |
143 | 143 |
144 class StopWatcher : public BaseWatcher { | 144 class StopWatcher : public BaseWatcher { |
145 public: | 145 public: |
146 explicit StopWatcher( | 146 explicit StopWatcher( |
147 MessagePumpLibevent::FileDescriptorWatcher* controller) | 147 MessagePumpLibevent::FileDescriptorWatcher* controller) |
148 : BaseWatcher(controller) {} | 148 : BaseWatcher(controller) {} |
149 | 149 |
150 virtual ~StopWatcher() {} | 150 virtual ~StopWatcher() {} |
151 | 151 |
152 virtual void OnFileCanWriteWithoutBlocking(int /* fd */) OVERRIDE { | 152 virtual void OnFileCanWriteWithoutBlocking(int /* fd */) override { |
153 controller_->StopWatchingFileDescriptor(); | 153 controller_->StopWatchingFileDescriptor(); |
154 } | 154 } |
155 }; | 155 }; |
156 | 156 |
157 TEST_F(MessagePumpLibeventTest, StopWatcher) { | 157 TEST_F(MessagePumpLibeventTest, StopWatcher) { |
158 scoped_ptr<MessagePumpLibevent> pump(new MessagePumpLibevent); | 158 scoped_ptr<MessagePumpLibevent> pump(new MessagePumpLibevent); |
159 MessagePumpLibevent::FileDescriptorWatcher watcher; | 159 MessagePumpLibevent::FileDescriptorWatcher watcher; |
160 StopWatcher delegate(&watcher); | 160 StopWatcher delegate(&watcher); |
161 pump->WatchFileDescriptor(pipefds_[1], | 161 pump->WatchFileDescriptor(pipefds_[1], |
162 false, MessagePumpLibevent::WATCH_READ_WRITE, &watcher, &delegate); | 162 false, MessagePumpLibevent::WATCH_READ_WRITE, &watcher, &delegate); |
163 | 163 |
164 // Spoof a libevent notification. | 164 // Spoof a libevent notification. |
165 OnLibeventNotification(pump.get(), &watcher); | 165 OnLibeventNotification(pump.get(), &watcher); |
166 } | 166 } |
167 | 167 |
168 void QuitMessageLoopAndStart(const Closure& quit_closure) { | 168 void QuitMessageLoopAndStart(const Closure& quit_closure) { |
169 quit_closure.Run(); | 169 quit_closure.Run(); |
170 | 170 |
171 MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current()); | 171 MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current()); |
172 RunLoop runloop; | 172 RunLoop runloop; |
173 MessageLoop::current()->PostTask(FROM_HERE, runloop.QuitClosure()); | 173 MessageLoop::current()->PostTask(FROM_HERE, runloop.QuitClosure()); |
174 runloop.Run(); | 174 runloop.Run(); |
175 } | 175 } |
176 | 176 |
177 class NestedPumpWatcher : public MessagePumpLibevent::Watcher { | 177 class NestedPumpWatcher : public MessagePumpLibevent::Watcher { |
178 public: | 178 public: |
179 NestedPumpWatcher() {} | 179 NestedPumpWatcher() {} |
180 virtual ~NestedPumpWatcher() {} | 180 virtual ~NestedPumpWatcher() {} |
181 | 181 |
182 virtual void OnFileCanReadWithoutBlocking(int /* fd */) OVERRIDE { | 182 virtual void OnFileCanReadWithoutBlocking(int /* fd */) override { |
183 RunLoop runloop; | 183 RunLoop runloop; |
184 MessageLoop::current()->PostTask(FROM_HERE, Bind(&QuitMessageLoopAndStart, | 184 MessageLoop::current()->PostTask(FROM_HERE, Bind(&QuitMessageLoopAndStart, |
185 runloop.QuitClosure())); | 185 runloop.QuitClosure())); |
186 runloop.Run(); | 186 runloop.Run(); |
187 } | 187 } |
188 | 188 |
189 virtual void OnFileCanWriteWithoutBlocking(int /* fd */) OVERRIDE {} | 189 virtual void OnFileCanWriteWithoutBlocking(int /* fd */) override {} |
190 }; | 190 }; |
191 | 191 |
192 TEST_F(MessagePumpLibeventTest, NestedPumpWatcher) { | 192 TEST_F(MessagePumpLibeventTest, NestedPumpWatcher) { |
193 scoped_ptr<MessagePumpLibevent> pump(new MessagePumpLibevent); | 193 scoped_ptr<MessagePumpLibevent> pump(new MessagePumpLibevent); |
194 MessagePumpLibevent::FileDescriptorWatcher watcher; | 194 MessagePumpLibevent::FileDescriptorWatcher watcher; |
195 NestedPumpWatcher delegate; | 195 NestedPumpWatcher delegate; |
196 pump->WatchFileDescriptor(pipefds_[1], | 196 pump->WatchFileDescriptor(pipefds_[1], |
197 false, MessagePumpLibevent::WATCH_READ, &watcher, &delegate); | 197 false, MessagePumpLibevent::WATCH_READ, &watcher, &delegate); |
198 | 198 |
199 // Spoof a libevent notification. | 199 // Spoof a libevent notification. |
200 OnLibeventNotification(pump.get(), &watcher); | 200 OnLibeventNotification(pump.get(), &watcher); |
201 } | 201 } |
202 | 202 |
203 } // namespace | 203 } // namespace |
204 | 204 |
205 } // namespace base | 205 } // namespace base |
OLD | NEW |