OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 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 <string> | 5 #include <string> |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/callback.h" | 8 #include "base/callback.h" |
9 #include "base/files/file.h" | 9 #include "base/files/file.h" |
10 #include "base/files/file_path.h" | 10 #include "base/files/file_path.h" |
11 #include "base/memory/scoped_ptr.h" | 11 #include "base/memory/scoped_ptr.h" |
12 #include "base/memory/scoped_vector.h" | 12 #include "base/memory/scoped_vector.h" |
13 #include "base/memory/weak_ptr.h" | 13 #include "base/memory/weak_ptr.h" |
14 #include "base/run_loop.h" | 14 #include "base/run_loop.h" |
15 #include "base/values.h" | |
16 #include "chrome/browser/chromeos/file_system_provider/request_manager.h" | 15 #include "chrome/browser/chromeos/file_system_provider/request_manager.h" |
| 16 #include "chrome/browser/chromeos/file_system_provider/request_value.h" |
17 #include "content/public/test/test_browser_thread_bundle.h" | 17 #include "content/public/test/test_browser_thread_bundle.h" |
18 #include "testing/gtest/include/gtest/gtest.h" | 18 #include "testing/gtest/include/gtest/gtest.h" |
19 | 19 |
20 namespace chromeos { | 20 namespace chromeos { |
21 namespace file_system_provider { | 21 namespace file_system_provider { |
22 namespace { | 22 namespace { |
23 | 23 |
24 // Logs calls of the success and error callbacks on requests. | 24 // Logs calls of the success and error callbacks on requests. |
25 class EventLogger { | 25 class EventLogger { |
26 public: | 26 public: |
| 27 class ExecuteEvent { |
| 28 public: |
| 29 explicit ExecuteEvent(int request_id) : request_id_(request_id) {} |
| 30 virtual ~ExecuteEvent() {} |
| 31 |
| 32 int request_id() { return request_id_; } |
| 33 |
| 34 private: |
| 35 int request_id_; |
| 36 }; |
| 37 |
27 class SuccessEvent { | 38 class SuccessEvent { |
28 public: | 39 public: |
29 SuccessEvent(scoped_ptr<base::DictionaryValue> result, bool has_next) | 40 SuccessEvent(int request_id, scoped_ptr<RequestValue> result, bool has_next) |
30 : result_(result.Pass()), has_next_(has_next) {} | 41 : request_id_(request_id), |
31 ~SuccessEvent() {} | 42 result_(result.Pass()), |
| 43 has_next_(has_next) {} |
| 44 virtual ~SuccessEvent() {} |
32 | 45 |
33 base::DictionaryValue* result() { return result_.get(); } | 46 int request_id() { return request_id_; } |
| 47 RequestValue* result() { return result_.get(); } |
34 bool has_next() { return has_next_; } | 48 bool has_next() { return has_next_; } |
35 | 49 |
36 private: | 50 private: |
37 scoped_ptr<base::DictionaryValue> result_; | 51 int request_id_; |
| 52 scoped_ptr<RequestValue> result_; |
38 bool has_next_; | 53 bool has_next_; |
39 }; | 54 }; |
40 | 55 |
41 class ErrorEvent { | 56 class ErrorEvent { |
42 public: | 57 public: |
43 explicit ErrorEvent(base::File::Error error) : error_(error) {} | 58 ErrorEvent(int request_id, base::File::Error error) |
44 ~ErrorEvent() {} | 59 : request_id_(request_id), error_(error) {} |
| 60 virtual ~ErrorEvent() {} |
45 | 61 |
| 62 int request_id() { return request_id_; } |
46 base::File::Error error() { return error_; } | 63 base::File::Error error() { return error_; } |
47 | 64 |
48 private: | 65 private: |
| 66 int request_id_; |
49 base::File::Error error_; | 67 base::File::Error error_; |
50 }; | 68 }; |
51 | 69 |
52 EventLogger() : weak_ptr_factory_(this) {} | 70 EventLogger() : weak_ptr_factory_(this) {} |
53 virtual ~EventLogger() {} | 71 virtual ~EventLogger() {} |
54 | 72 |
55 void OnSuccess(scoped_ptr<base::DictionaryValue> result, bool has_next) { | 73 void OnExecute(int request_id) { |
56 success_events_.push_back(new SuccessEvent(result.Pass(), has_next)); | 74 execute_events_.push_back(new ExecuteEvent(request_id)); |
57 } | 75 } |
58 | 76 |
59 void OnError(base::File::Error error) { | 77 void OnSuccess(int request_id, |
60 error_events_.push_back(new ErrorEvent(error)); | 78 scoped_ptr<RequestValue> result, |
| 79 bool has_next) { |
| 80 success_events_.push_back( |
| 81 new SuccessEvent(request_id, result.Pass(), has_next)); |
61 } | 82 } |
62 | 83 |
| 84 void OnError(int request_id, base::File::Error error) { |
| 85 error_events_.push_back(new ErrorEvent(request_id, error)); |
| 86 } |
| 87 |
| 88 ScopedVector<ExecuteEvent>& execute_events() { return execute_events_; } |
63 ScopedVector<SuccessEvent>& success_events() { return success_events_; } | 89 ScopedVector<SuccessEvent>& success_events() { return success_events_; } |
64 ScopedVector<ErrorEvent>& error_events() { return error_events_; } | 90 ScopedVector<ErrorEvent>& error_events() { return error_events_; } |
65 | 91 |
66 base::WeakPtr<EventLogger> GetWeakPtr() { | 92 base::WeakPtr<EventLogger> GetWeakPtr() { |
67 return weak_ptr_factory_.GetWeakPtr(); | 93 return weak_ptr_factory_.GetWeakPtr(); |
68 } | 94 } |
69 | 95 |
70 private: | 96 private: |
| 97 ScopedVector<ExecuteEvent> execute_events_; |
71 ScopedVector<SuccessEvent> success_events_; | 98 ScopedVector<SuccessEvent> success_events_; |
72 ScopedVector<ErrorEvent> error_events_; | 99 ScopedVector<ErrorEvent> error_events_; |
73 base::WeakPtrFactory<EventLogger> weak_ptr_factory_; | 100 base::WeakPtrFactory<EventLogger> weak_ptr_factory_; |
| 101 |
| 102 DISALLOW_COPY_AND_ASSIGN(EventLogger); |
| 103 }; |
| 104 |
| 105 // Fake handler, which forwards callbacks to the logger. The handler is owned |
| 106 // by a request manager, however the logger is owned by tests. |
| 107 class FakeHandler : public RequestManager::HandlerInterface { |
| 108 public: |
| 109 // The handler can outlive the passed logger, so using a weak pointer. The |
| 110 // |execute_reply| value will be returned for the Execute() call. |
| 111 FakeHandler(base::WeakPtr<EventLogger> logger, bool execute_reply) |
| 112 : logger_(logger), execute_reply_(execute_reply) {} |
| 113 |
| 114 // RequestManager::Handler overrides. |
| 115 virtual bool Execute(int request_id) OVERRIDE { |
| 116 if (logger_.get()) |
| 117 logger_->OnExecute(request_id); |
| 118 |
| 119 return execute_reply_; |
| 120 } |
| 121 |
| 122 // RequestManager::Handler overrides. |
| 123 virtual void OnSuccess(int request_id, |
| 124 scoped_ptr<RequestValue> result, |
| 125 bool has_next) OVERRIDE { |
| 126 if (logger_.get()) |
| 127 logger_->OnSuccess(request_id, result.Pass(), has_next); |
| 128 } |
| 129 |
| 130 // RequestManager::Handler overrides. |
| 131 virtual void OnError(int request_id, base::File::Error error) OVERRIDE { |
| 132 if (logger_.get()) |
| 133 logger_->OnError(request_id, error); |
| 134 } |
| 135 |
| 136 virtual ~FakeHandler() {} |
| 137 |
| 138 private: |
| 139 base::WeakPtr<EventLogger> logger_; |
| 140 bool execute_reply_; |
| 141 DISALLOW_COPY_AND_ASSIGN(FakeHandler); |
74 }; | 142 }; |
75 | 143 |
76 } // namespace | 144 } // namespace |
77 | 145 |
78 class FileSystemProviderRequestManagerTest : public testing::Test { | 146 class FileSystemProviderRequestManagerTest : public testing::Test { |
79 protected: | 147 protected: |
80 FileSystemProviderRequestManagerTest() {} | 148 FileSystemProviderRequestManagerTest() {} |
81 virtual ~FileSystemProviderRequestManagerTest() {} | 149 virtual ~FileSystemProviderRequestManagerTest() {} |
82 | 150 |
83 virtual void SetUp() OVERRIDE { | 151 virtual void SetUp() OVERRIDE { |
84 request_manager_.reset(new RequestManager()); | 152 request_manager_.reset(new RequestManager()); |
85 } | 153 } |
86 | 154 |
87 content::TestBrowserThreadBundle thread_bundle_; | 155 content::TestBrowserThreadBundle thread_bundle_; |
88 scoped_ptr<RequestManager> request_manager_; | 156 scoped_ptr<RequestManager> request_manager_; |
89 }; | 157 }; |
90 | 158 |
91 TEST_F(FileSystemProviderRequestManagerTest, CreateAndFulFill) { | 159 TEST_F(FileSystemProviderRequestManagerTest, CreateAndFulFill) { |
92 EventLogger logger; | 160 EventLogger logger; |
93 | 161 |
94 int request_id = request_manager_->CreateRequest( | 162 const int request_id = request_manager_->CreateRequest( |
95 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | 163 make_scoped_ptr<RequestManager::HandlerInterface>( |
96 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | 164 new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */))); |
97 | 165 |
98 EXPECT_EQ(1, request_id); | 166 EXPECT_EQ(1, request_id); |
99 EXPECT_EQ(0u, logger.success_events().size()); | 167 EXPECT_EQ(0u, logger.success_events().size()); |
100 EXPECT_EQ(0u, logger.error_events().size()); | 168 EXPECT_EQ(0u, logger.error_events().size()); |
101 | 169 |
102 scoped_ptr<base::DictionaryValue> response(new base::DictionaryValue()); | 170 scoped_ptr<RequestValue> response( |
| 171 RequestValue::CreateForTesting("i-like-vanilla")); |
103 const bool has_next = false; | 172 const bool has_next = false; |
104 response->SetString("path", "i-like-vanilla"); | |
105 | 173 |
106 bool result = | 174 bool result = |
107 request_manager_->FulfillRequest(request_id, response.Pass(), has_next); | 175 request_manager_->FulfillRequest(request_id, response.Pass(), has_next); |
108 EXPECT_TRUE(result); | 176 EXPECT_TRUE(result); |
109 | 177 |
110 // Validate if the callback has correct arguments. | 178 // Validate if the callback has correct arguments. |
111 ASSERT_EQ(1u, logger.success_events().size()); | 179 ASSERT_EQ(1u, logger.success_events().size()); |
112 EXPECT_EQ(0u, logger.error_events().size()); | 180 EXPECT_EQ(0u, logger.error_events().size()); |
113 EventLogger::SuccessEvent* event = logger.success_events()[0]; | 181 EventLogger::SuccessEvent* event = logger.success_events()[0]; |
114 ASSERT_TRUE(event->result()); | 182 ASSERT_TRUE(event->result()); |
115 std::string response_test_string; | 183 const std::string* response_test_string = event->result()->testing_params(); |
116 EXPECT_TRUE(event->result()->GetString("path", &response_test_string)); | 184 ASSERT_TRUE(response_test_string); |
117 EXPECT_EQ("i-like-vanilla", response_test_string); | 185 EXPECT_EQ("i-like-vanilla", *response_test_string); |
118 EXPECT_FALSE(event->has_next()); | 186 EXPECT_FALSE(event->has_next()); |
119 | 187 |
120 // Confirm, that the request is removed. Basically, fulfilling again for the | 188 // Confirm, that the request is removed. Basically, fulfilling again for the |
121 // same request, should fail. | 189 // same request, should fail. |
122 { | 190 { |
123 scoped_ptr<base::DictionaryValue> response; | 191 scoped_ptr<RequestValue> response; |
124 bool retry = | 192 bool retry = |
125 request_manager_->FulfillRequest(request_id, response.Pass(), has_next); | 193 request_manager_->FulfillRequest(request_id, response.Pass(), has_next); |
126 EXPECT_FALSE(retry); | 194 EXPECT_FALSE(retry); |
127 } | 195 } |
128 | 196 |
129 // Rejecting should also fail. | 197 // Rejecting should also fail. |
130 { | 198 { |
131 bool retry = request_manager_->RejectRequest(request_id, | 199 bool retry = request_manager_->RejectRequest(request_id, |
132 base::File::FILE_ERROR_FAILED); | 200 base::File::FILE_ERROR_FAILED); |
133 EXPECT_FALSE(retry); | 201 EXPECT_FALSE(retry); |
134 } | 202 } |
135 } | 203 } |
136 | 204 |
137 TEST_F(FileSystemProviderRequestManagerTest, CreateAndFulFill_WithHasNext) { | 205 TEST_F(FileSystemProviderRequestManagerTest, CreateAndFulFill_WithHasNext) { |
138 EventLogger logger; | 206 EventLogger logger; |
139 | 207 |
140 int request_id = request_manager_->CreateRequest( | 208 const int request_id = request_manager_->CreateRequest( |
141 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | 209 make_scoped_ptr<RequestManager::HandlerInterface>( |
142 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | 210 new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */))); |
143 | 211 |
144 EXPECT_EQ(1, request_id); | 212 EXPECT_EQ(1, request_id); |
145 EXPECT_EQ(0u, logger.success_events().size()); | 213 EXPECT_EQ(0u, logger.success_events().size()); |
146 EXPECT_EQ(0u, logger.error_events().size()); | 214 EXPECT_EQ(0u, logger.error_events().size()); |
147 | 215 |
148 scoped_ptr<base::DictionaryValue> response; | 216 scoped_ptr<RequestValue> response; |
149 const bool has_next = true; | 217 const bool has_next = true; |
150 | 218 |
151 bool result = | 219 bool result = |
152 request_manager_->FulfillRequest(request_id, response.Pass(), has_next); | 220 request_manager_->FulfillRequest(request_id, response.Pass(), has_next); |
153 EXPECT_TRUE(result); | 221 EXPECT_TRUE(result); |
154 | 222 |
155 // Validate if the callback has correct arguments. | 223 // Validate if the callback has correct arguments. |
156 ASSERT_EQ(1u, logger.success_events().size()); | 224 ASSERT_EQ(1u, logger.success_events().size()); |
157 EXPECT_EQ(0u, logger.error_events().size()); | 225 EXPECT_EQ(0u, logger.error_events().size()); |
158 EventLogger::SuccessEvent* event = logger.success_events()[0]; | 226 EventLogger::SuccessEvent* event = logger.success_events()[0]; |
(...skipping 15 matching lines...) Expand all Loading... |
174 bool new_has_next = false; | 242 bool new_has_next = false; |
175 bool retry = request_manager_->FulfillRequest( | 243 bool retry = request_manager_->FulfillRequest( |
176 request_id, response.Pass(), new_has_next); | 244 request_id, response.Pass(), new_has_next); |
177 EXPECT_FALSE(retry); | 245 EXPECT_FALSE(retry); |
178 } | 246 } |
179 } | 247 } |
180 | 248 |
181 TEST_F(FileSystemProviderRequestManagerTest, CreateAndReject) { | 249 TEST_F(FileSystemProviderRequestManagerTest, CreateAndReject) { |
182 EventLogger logger; | 250 EventLogger logger; |
183 | 251 |
184 int request_id = request_manager_->CreateRequest( | 252 const int request_id = request_manager_->CreateRequest( |
185 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | 253 make_scoped_ptr<RequestManager::HandlerInterface>( |
186 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | 254 new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */))); |
187 | 255 |
188 EXPECT_EQ(1, request_id); | 256 EXPECT_EQ(1, request_id); |
189 EXPECT_EQ(0u, logger.success_events().size()); | 257 EXPECT_EQ(0u, logger.success_events().size()); |
190 EXPECT_EQ(0u, logger.error_events().size()); | 258 EXPECT_EQ(0u, logger.error_events().size()); |
191 | 259 |
192 base::File::Error error = base::File::FILE_ERROR_NO_MEMORY; | 260 base::File::Error error = base::File::FILE_ERROR_NO_MEMORY; |
193 bool result = request_manager_->RejectRequest(request_id, error); | 261 bool result = request_manager_->RejectRequest(request_id, error); |
194 EXPECT_TRUE(result); | 262 EXPECT_TRUE(result); |
195 | 263 |
196 // Validate if the callback has correct arguments. | 264 // Validate if the callback has correct arguments. |
197 ASSERT_EQ(1u, logger.error_events().size()); | 265 ASSERT_EQ(1u, logger.error_events().size()); |
198 EXPECT_EQ(0u, logger.success_events().size()); | 266 EXPECT_EQ(0u, logger.success_events().size()); |
199 EventLogger::ErrorEvent* event = logger.error_events()[0]; | 267 EventLogger::ErrorEvent* event = logger.error_events()[0]; |
200 EXPECT_EQ(error, event->error()); | 268 EXPECT_EQ(error, event->error()); |
201 | 269 |
202 // Confirm, that the request is removed. Basically, fulfilling again for the | 270 // Confirm, that the request is removed. Basically, fulfilling again for the |
203 // same request, should fail. | 271 // same request, should fail. |
204 { | 272 { |
205 scoped_ptr<base::DictionaryValue> response; | 273 scoped_ptr<RequestValue> response; |
206 bool has_next = false; | 274 bool has_next = false; |
207 bool retry = | 275 bool retry = |
208 request_manager_->FulfillRequest(request_id, response.Pass(), has_next); | 276 request_manager_->FulfillRequest(request_id, response.Pass(), has_next); |
209 EXPECT_FALSE(retry); | 277 EXPECT_FALSE(retry); |
210 } | 278 } |
211 | 279 |
212 // Rejecting should also fail. | 280 // Rejecting should also fail. |
213 { | 281 { |
214 bool retry = request_manager_->RejectRequest(request_id, error); | 282 bool retry = request_manager_->RejectRequest(request_id, error); |
215 EXPECT_FALSE(retry); | 283 EXPECT_FALSE(retry); |
216 } | 284 } |
217 } | 285 } |
218 | 286 |
219 TEST_F(FileSystemProviderRequestManagerTest, | 287 TEST_F(FileSystemProviderRequestManagerTest, |
220 CreateAndFulfillWithWrongRequestId) { | 288 CreateAndFulfillWithWrongRequestId) { |
221 EventLogger logger; | 289 EventLogger logger; |
222 | 290 |
223 int request_id = request_manager_->CreateRequest( | 291 const int request_id = request_manager_->CreateRequest( |
224 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | 292 make_scoped_ptr<RequestManager::HandlerInterface>( |
225 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | 293 new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */))); |
226 | 294 |
227 EXPECT_EQ(1, request_id); | 295 EXPECT_EQ(1, request_id); |
228 EXPECT_EQ(0u, logger.success_events().size()); | 296 EXPECT_EQ(0u, logger.success_events().size()); |
229 EXPECT_EQ(0u, logger.error_events().size()); | 297 EXPECT_EQ(0u, logger.error_events().size()); |
230 | 298 |
231 base::File::Error error = base::File::FILE_ERROR_NO_MEMORY; | 299 base::File::Error error = base::File::FILE_ERROR_NO_MEMORY; |
232 bool result = request_manager_->RejectRequest(request_id + 1, error); | 300 bool result = request_manager_->RejectRequest(request_id + 1, error); |
233 EXPECT_FALSE(result); | 301 EXPECT_FALSE(result); |
234 | 302 |
235 // Callbacks should not be called. | 303 // Callbacks should not be called. |
236 EXPECT_EQ(0u, logger.error_events().size()); | 304 EXPECT_EQ(0u, logger.error_events().size()); |
237 EXPECT_EQ(0u, logger.success_events().size()); | 305 EXPECT_EQ(0u, logger.success_events().size()); |
238 | 306 |
239 // Confirm, that the request hasn't been removed, by rejecting it correctly. | 307 // Confirm, that the request hasn't been removed, by rejecting it correctly. |
240 { | 308 { |
241 bool retry = request_manager_->RejectRequest(request_id, error); | 309 bool retry = request_manager_->RejectRequest(request_id, error); |
242 EXPECT_TRUE(retry); | 310 EXPECT_TRUE(retry); |
243 } | 311 } |
244 } | 312 } |
245 | 313 |
246 TEST_F(FileSystemProviderRequestManagerTest, | 314 TEST_F(FileSystemProviderRequestManagerTest, |
247 CreateAndRejectWithWrongRequestId) { | 315 CreateAndRejectWithWrongRequestId) { |
248 EventLogger logger; | 316 EventLogger logger; |
249 | 317 |
250 int request_id = request_manager_->CreateRequest( | 318 const int request_id = request_manager_->CreateRequest( |
251 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | 319 make_scoped_ptr<RequestManager::HandlerInterface>( |
252 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | 320 new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */))); |
253 | 321 |
254 EXPECT_EQ(1, request_id); | 322 EXPECT_EQ(1, request_id); |
255 EXPECT_EQ(0u, logger.success_events().size()); | 323 EXPECT_EQ(0u, logger.success_events().size()); |
256 EXPECT_EQ(0u, logger.error_events().size()); | 324 EXPECT_EQ(0u, logger.error_events().size()); |
257 | 325 |
258 base::File::Error error = base::File::FILE_ERROR_NO_MEMORY; | 326 base::File::Error error = base::File::FILE_ERROR_NO_MEMORY; |
259 bool result = request_manager_->RejectRequest(request_id + 1, error); | 327 bool result = request_manager_->RejectRequest(request_id + 1, error); |
260 EXPECT_FALSE(result); | 328 EXPECT_FALSE(result); |
261 | 329 |
262 // Callbacks should not be called. | 330 // Callbacks should not be called. |
263 EXPECT_EQ(0u, logger.error_events().size()); | 331 EXPECT_EQ(0u, logger.error_events().size()); |
264 EXPECT_EQ(0u, logger.success_events().size()); | 332 EXPECT_EQ(0u, logger.success_events().size()); |
265 | 333 |
266 // Confirm, that the request hasn't been removed, by rejecting it correctly. | 334 // Confirm, that the request hasn't been removed, by rejecting it correctly. |
267 { | 335 { |
268 bool retry = request_manager_->RejectRequest(request_id, error); | 336 bool retry = request_manager_->RejectRequest(request_id, error); |
269 EXPECT_TRUE(retry); | 337 EXPECT_TRUE(retry); |
270 } | 338 } |
271 } | 339 } |
272 | 340 |
273 TEST_F(FileSystemProviderRequestManagerTest, UniqueIds) { | 341 TEST_F(FileSystemProviderRequestManagerTest, UniqueIds) { |
274 EventLogger logger; | 342 EventLogger logger; |
275 | 343 |
276 int first_request_id = request_manager_->CreateRequest( | 344 const int first_request_id = request_manager_->CreateRequest( |
277 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | 345 make_scoped_ptr<RequestManager::HandlerInterface>( |
278 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | 346 new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */))); |
279 | 347 |
280 int second_request_id = request_manager_->CreateRequest( | 348 const int second_request_id = request_manager_->CreateRequest( |
281 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | 349 make_scoped_ptr<RequestManager::HandlerInterface>( |
282 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | 350 new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */))); |
283 | 351 |
284 EXPECT_EQ(1, first_request_id); | 352 EXPECT_EQ(1, first_request_id); |
285 EXPECT_EQ(2, second_request_id); | 353 EXPECT_EQ(2, second_request_id); |
286 } | 354 } |
287 | 355 |
288 TEST_F(FileSystemProviderRequestManagerTest, AbortOnDestroy) { | 356 TEST_F(FileSystemProviderRequestManagerTest, AbortOnDestroy) { |
289 EventLogger logger; | 357 EventLogger logger; |
290 | 358 |
291 { | 359 { |
292 RequestManager request_manager; | 360 RequestManager request_manager; |
293 int request_id = request_manager.CreateRequest( | 361 const int request_id = request_manager.CreateRequest( |
294 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | 362 make_scoped_ptr<RequestManager::HandlerInterface>( |
295 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | 363 new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */))); |
296 | 364 |
297 EXPECT_EQ(1, request_id); | 365 EXPECT_EQ(1, request_id); |
298 EXPECT_EQ(0u, logger.success_events().size()); | 366 EXPECT_EQ(0u, logger.success_events().size()); |
299 EXPECT_EQ(0u, logger.error_events().size()); | 367 EXPECT_EQ(0u, logger.error_events().size()); |
300 } | 368 } |
301 | 369 |
302 // All active requests should be aborted in the destructor of RequestManager. | 370 // All active requests should be aborted in the destructor of RequestManager. |
| 371 ASSERT_EQ(1u, logger.error_events().size()); |
303 EventLogger::ErrorEvent* event = logger.error_events()[0]; | 372 EventLogger::ErrorEvent* event = logger.error_events()[0]; |
304 ASSERT_EQ(1u, logger.error_events().size()); | |
305 EXPECT_EQ(base::File::FILE_ERROR_ABORT, event->error()); | 373 EXPECT_EQ(base::File::FILE_ERROR_ABORT, event->error()); |
306 | 374 |
307 EXPECT_EQ(0u, logger.success_events().size()); | 375 EXPECT_EQ(0u, logger.success_events().size()); |
308 } | 376 } |
309 | 377 |
310 TEST_F(FileSystemProviderRequestManagerTest, AbortOnTimeout) { | 378 TEST_F(FileSystemProviderRequestManagerTest, AbortOnTimeout) { |
311 EventLogger logger; | 379 EventLogger logger; |
312 base::RunLoop run_loop; | 380 base::RunLoop run_loop; |
313 | 381 |
314 request_manager_->SetTimeoutForTests(base::TimeDelta::FromSeconds(0)); | 382 request_manager_->SetTimeoutForTests(base::TimeDelta::FromSeconds(0)); |
315 int request_id = request_manager_->CreateRequest( | 383 const int request_id = request_manager_->CreateRequest( |
316 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | 384 make_scoped_ptr<RequestManager::HandlerInterface>( |
317 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | 385 new FakeHandler(logger.GetWeakPtr(), true /* execute_reply */))); |
318 EXPECT_LT(0, request_id); | 386 EXPECT_LT(0, request_id); |
319 | 387 |
320 // Wait until the request is timeouted. | 388 // Wait until the request is timeouted. |
321 run_loop.RunUntilIdle(); | 389 run_loop.RunUntilIdle(); |
322 | 390 |
323 ASSERT_EQ(1u, logger.error_events().size()); | 391 ASSERT_EQ(1u, logger.error_events().size()); |
324 EventLogger::ErrorEvent* event = logger.error_events()[0]; | 392 EventLogger::ErrorEvent* event = logger.error_events()[0]; |
325 EXPECT_EQ(base::File::FILE_ERROR_ABORT, event->error()); | 393 EXPECT_EQ(base::File::FILE_ERROR_ABORT, event->error()); |
326 } | 394 } |
327 | 395 |
328 } // namespace file_system_provider | 396 } // namespace file_system_provider |
329 } // namespace chromeos | 397 } // namespace chromeos |
OLD | NEW |