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/files/file.h" | 8 #include "base/files/file.h" |
9 #include "base/files/file_path.h" | 9 #include "base/files/file_path.h" |
10 #include "base/memory/scoped_ptr.h" | 10 #include "base/memory/scoped_ptr.h" |
11 #include "base/memory/scoped_vector.h" | 11 #include "base/memory/scoped_vector.h" |
12 #include "base/memory/weak_ptr.h" | 12 #include "base/memory/weak_ptr.h" |
13 #include "base/values.h" | 13 #include "base/values.h" |
14 #include "chrome/browser/chromeos/file_system_provider/request_manager.h" | 14 #include "chrome/browser/chromeos/file_system_provider/request_manager.h" |
15 #include "testing/gtest/include/gtest/gtest.h" | 15 #include "testing/gtest/include/gtest/gtest.h" |
16 | 16 |
17 namespace chromeos { | 17 namespace chromeos { |
18 namespace file_system_provider { | 18 namespace file_system_provider { |
19 namespace { | 19 namespace { |
20 | 20 |
21 const char kExtensionId[] = "mbflcebpggnecokmikipoihdbecnjfoj"; | 21 const char kExtensionId[] = "mbflcebpggnecokmikipoihdbecnjfoj"; |
22 const int kFileSystemId = 1; | 22 const int kFileSystemId = 1; |
23 const char kFileSystemName[] = "Camera Pictures"; | |
24 const base::FilePath::CharType kMountPath[] = FILE_PATH_LITERAL( | |
25 "/provided/mbflcebpggnecokmikipoihdbecnjfoj-1-testing_profile-hash"); | |
26 | 23 |
27 // Logs calls of the success and error callbacks on requests. | 24 // Logs calls of the success and error callbacks on requests. |
28 class EventLogger { | 25 class EventLogger { |
29 public: | 26 public: |
30 class SuccessEvent { | 27 class SuccessEvent { |
31 public: | 28 public: |
32 SuccessEvent(scoped_ptr<base::DictionaryValue> result, bool has_next) | 29 SuccessEvent(scoped_ptr<base::DictionaryValue> result, bool has_next) |
33 : result_(result.Pass()), has_next_(has_next) {} | 30 : result_(result.Pass()), has_next_(has_next) {} |
34 ~SuccessEvent() {} | 31 ~SuccessEvent() {} |
35 | 32 |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
78 | 75 |
79 } // namespace | 76 } // namespace |
80 | 77 |
81 class FileSystemProviderRequestManagerTest : public testing::Test { | 78 class FileSystemProviderRequestManagerTest : public testing::Test { |
82 protected: | 79 protected: |
83 FileSystemProviderRequestManagerTest() {} | 80 FileSystemProviderRequestManagerTest() {} |
84 virtual ~FileSystemProviderRequestManagerTest() {} | 81 virtual ~FileSystemProviderRequestManagerTest() {} |
85 | 82 |
86 virtual void SetUp() OVERRIDE { | 83 virtual void SetUp() OVERRIDE { |
87 request_manager_.reset(new RequestManager()); | 84 request_manager_.reset(new RequestManager()); |
88 | |
89 // Configure the testing file system. | |
90 file_system = ProvidedFileSystem(kExtensionId, | |
91 kFileSystemId, | |
92 kFileSystemName, | |
93 base::FilePath(kMountPath)); | |
94 } | 85 } |
95 | 86 |
96 scoped_ptr<RequestManager> request_manager_; | 87 scoped_ptr<RequestManager> request_manager_; |
97 ProvidedFileSystem file_system; | |
98 }; | 88 }; |
99 | 89 |
100 TEST_F(FileSystemProviderRequestManagerTest, CreateAndFulFill) { | 90 TEST_F(FileSystemProviderRequestManagerTest, CreateAndFulFill) { |
101 EventLogger logger; | 91 EventLogger logger; |
102 | 92 |
103 int request_id = request_manager_->CreateRequest( | 93 int request_id = request_manager_->CreateRequest( |
104 file_system, | 94 kExtensionId, |
| 95 kFileSystemId, |
105 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | 96 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), |
106 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | 97 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); |
107 | 98 |
108 EXPECT_EQ(1, request_id); | 99 EXPECT_EQ(1, request_id); |
109 EXPECT_EQ(0u, logger.success_events().size()); | 100 EXPECT_EQ(0u, logger.success_events().size()); |
110 EXPECT_EQ(0u, logger.error_events().size()); | 101 EXPECT_EQ(0u, logger.error_events().size()); |
111 | 102 |
112 scoped_ptr<base::DictionaryValue> response(new base::DictionaryValue()); | 103 scoped_ptr<base::DictionaryValue> response(new base::DictionaryValue()); |
113 const bool has_next = false; | 104 const bool has_next = false; |
114 response->SetString("path", "i-like-vanilla"); | 105 response->SetString("path", "i-like-vanilla"); |
115 | 106 |
116 bool result = request_manager_->FulfillRequest( | 107 bool result = request_manager_->FulfillRequest( |
117 file_system, request_id, response.Pass(), has_next); | 108 kExtensionId, kFileSystemId, request_id, response.Pass(), has_next); |
118 EXPECT_TRUE(result); | 109 EXPECT_TRUE(result); |
119 | 110 |
120 // Validate if the callback has correct arguments. | 111 // Validate if the callback has correct arguments. |
121 ASSERT_EQ(1u, logger.success_events().size()); | 112 ASSERT_EQ(1u, logger.success_events().size()); |
122 EXPECT_EQ(0u, logger.error_events().size()); | 113 EXPECT_EQ(0u, logger.error_events().size()); |
123 EventLogger::SuccessEvent* event = logger.success_events()[0]; | 114 EventLogger::SuccessEvent* event = logger.success_events()[0]; |
124 ASSERT_TRUE(event->result()); | 115 ASSERT_TRUE(event->result()); |
125 std::string response_test_string; | 116 std::string response_test_string; |
126 EXPECT_TRUE(event->result()->GetString("path", &response_test_string)); | 117 EXPECT_TRUE(event->result()->GetString("path", &response_test_string)); |
127 EXPECT_EQ("i-like-vanilla", response_test_string); | 118 EXPECT_EQ("i-like-vanilla", response_test_string); |
128 EXPECT_EQ(has_next, event->has_next()); | 119 EXPECT_EQ(has_next, event->has_next()); |
129 | 120 |
130 // Confirm, that the request is removed. Basically, fulfilling again for the | 121 // Confirm, that the request is removed. Basically, fulfilling again for the |
131 // same request, should fail. | 122 // same request, should fail. |
132 { | 123 { |
| 124 scoped_ptr<base::DictionaryValue> response; |
133 bool retry = request_manager_->FulfillRequest( | 125 bool retry = request_manager_->FulfillRequest( |
134 file_system, request_id, response.Pass(), has_next); | 126 kExtensionId, kFileSystemId, request_id, response.Pass(), has_next); |
135 EXPECT_FALSE(retry); | 127 EXPECT_FALSE(retry); |
136 } | 128 } |
137 | 129 |
138 // Rejecting should also fail. | 130 // Rejecting should also fail. |
139 { | 131 { |
140 bool retry = request_manager_->RejectRequest( | 132 bool retry = request_manager_->RejectRequest( |
141 file_system, request_id, base::File::FILE_ERROR_FAILED); | 133 kExtensionId, kFileSystemId, request_id, base::File::FILE_ERROR_FAILED); |
142 EXPECT_FALSE(retry); | 134 EXPECT_FALSE(retry); |
143 } | 135 } |
144 } | 136 } |
145 | 137 |
146 TEST_F(FileSystemProviderRequestManagerTest, CreateAndFulFill_WithHasNext) { | 138 TEST_F(FileSystemProviderRequestManagerTest, CreateAndFulFill_WithHasNext) { |
147 EventLogger logger; | 139 EventLogger logger; |
148 | 140 |
149 int request_id = request_manager_->CreateRequest( | 141 int request_id = request_manager_->CreateRequest( |
150 file_system, | 142 kExtensionId, |
| 143 kFileSystemId, |
151 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | 144 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), |
152 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | 145 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); |
153 | 146 |
154 EXPECT_EQ(1, request_id); | 147 EXPECT_EQ(1, request_id); |
155 EXPECT_EQ(0u, logger.success_events().size()); | 148 EXPECT_EQ(0u, logger.success_events().size()); |
156 EXPECT_EQ(0u, logger.error_events().size()); | 149 EXPECT_EQ(0u, logger.error_events().size()); |
157 | 150 |
158 scoped_ptr<base::DictionaryValue> response; | 151 scoped_ptr<base::DictionaryValue> response; |
159 const bool has_next = true; | 152 const bool has_next = true; |
160 | 153 |
161 bool result = request_manager_->FulfillRequest( | 154 bool result = request_manager_->FulfillRequest( |
162 file_system, request_id, response.Pass(), has_next); | 155 kExtensionId, kFileSystemId, request_id, response.Pass(), has_next); |
163 EXPECT_TRUE(result); | 156 EXPECT_TRUE(result); |
164 | 157 |
165 // Validate if the callback has correct arguments. | 158 // Validate if the callback has correct arguments. |
166 ASSERT_EQ(1u, logger.success_events().size()); | 159 ASSERT_EQ(1u, logger.success_events().size()); |
167 EXPECT_EQ(0u, logger.error_events().size()); | 160 EXPECT_EQ(0u, logger.error_events().size()); |
168 EventLogger::SuccessEvent* event = logger.success_events()[0]; | 161 EventLogger::SuccessEvent* event = logger.success_events()[0]; |
169 EXPECT_FALSE(event->result()); | 162 EXPECT_FALSE(event->result()); |
170 EXPECT_EQ(has_next, event->has_next()); | 163 EXPECT_EQ(has_next, event->has_next()); |
171 | 164 |
172 // Confirm, that the request is not removed (since it has has_next == true). | 165 // Confirm, that the request is not removed (since it has has_next == true). |
173 // Basically, fulfilling again for the same request, should not fail. | 166 // Basically, fulfilling again for the same request, should not fail. |
174 { | 167 { |
175 bool new_has_next = false; | 168 bool new_has_next = false; |
176 bool retry = request_manager_->FulfillRequest( | 169 bool retry = request_manager_->FulfillRequest( |
177 file_system, request_id, response.Pass(), new_has_next); | 170 kExtensionId, kFileSystemId, request_id, response.Pass(), new_has_next); |
178 EXPECT_TRUE(retry); | 171 EXPECT_TRUE(retry); |
179 } | 172 } |
180 | 173 |
181 // Since |new_has_next| is false, then the request should be removed. To check | 174 // Since |new_has_next| is false, then the request should be removed. To check |
182 // it, try to fulfill again, what should fail. | 175 // it, try to fulfill again, what should fail. |
183 { | 176 { |
184 bool new_has_next = false; | 177 bool new_has_next = false; |
185 bool retry = request_manager_->FulfillRequest( | 178 bool retry = request_manager_->FulfillRequest( |
186 file_system, request_id, response.Pass(), new_has_next); | 179 kExtensionId, kFileSystemId, request_id, response.Pass(), new_has_next); |
187 EXPECT_FALSE(retry); | 180 EXPECT_FALSE(retry); |
188 } | 181 } |
189 } | 182 } |
190 | 183 |
191 TEST_F(FileSystemProviderRequestManagerTest, CreateAndReject) { | 184 TEST_F(FileSystemProviderRequestManagerTest, CreateAndReject) { |
192 EventLogger logger; | 185 EventLogger logger; |
193 | 186 |
194 int request_id = request_manager_->CreateRequest( | 187 int request_id = request_manager_->CreateRequest( |
195 file_system, | 188 kExtensionId, |
| 189 kFileSystemId, |
196 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | 190 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), |
197 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | 191 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); |
198 | 192 |
199 EXPECT_EQ(1, request_id); | 193 EXPECT_EQ(1, request_id); |
200 EXPECT_EQ(0u, logger.success_events().size()); | 194 EXPECT_EQ(0u, logger.success_events().size()); |
201 EXPECT_EQ(0u, logger.error_events().size()); | 195 EXPECT_EQ(0u, logger.error_events().size()); |
202 | 196 |
203 base::File::Error error = base::File::FILE_ERROR_NO_MEMORY; | 197 base::File::Error error = base::File::FILE_ERROR_NO_MEMORY; |
204 bool result = request_manager_->RejectRequest(file_system, request_id, error); | 198 bool result = request_manager_->RejectRequest( |
| 199 kExtensionId, kFileSystemId, request_id, error); |
205 EXPECT_TRUE(result); | 200 EXPECT_TRUE(result); |
206 | 201 |
207 // Validate if the callback has correct arguments. | 202 // Validate if the callback has correct arguments. |
208 ASSERT_EQ(1u, logger.error_events().size()); | 203 ASSERT_EQ(1u, logger.error_events().size()); |
209 EXPECT_EQ(0u, logger.success_events().size()); | 204 EXPECT_EQ(0u, logger.success_events().size()); |
210 EventLogger::ErrorEvent* event = logger.error_events()[0]; | 205 EventLogger::ErrorEvent* event = logger.error_events()[0]; |
211 EXPECT_EQ(error, event->error()); | 206 EXPECT_EQ(error, event->error()); |
212 | 207 |
213 // Confirm, that the request is removed. Basically, fulfilling again for the | 208 // Confirm, that the request is removed. Basically, fulfilling again for the |
214 // same request, should fail. | 209 // same request, should fail. |
215 { | 210 { |
216 scoped_ptr<base::DictionaryValue> response; | 211 scoped_ptr<base::DictionaryValue> response; |
217 bool has_next = false; | 212 bool has_next = false; |
218 bool retry = request_manager_->FulfillRequest( | 213 bool retry = request_manager_->FulfillRequest( |
219 file_system, request_id, response.Pass(), has_next); | 214 kExtensionId, kFileSystemId, request_id, response.Pass(), has_next); |
220 EXPECT_FALSE(retry); | 215 EXPECT_FALSE(retry); |
221 } | 216 } |
222 | 217 |
223 // Rejecting should also fail. | 218 // Rejecting should also fail. |
224 { | 219 { |
225 bool retry = | 220 bool retry = request_manager_->RejectRequest( |
226 request_manager_->RejectRequest(file_system, request_id, error); | 221 kExtensionId, kFileSystemId, request_id, error); |
227 EXPECT_FALSE(retry); | 222 EXPECT_FALSE(retry); |
228 } | 223 } |
229 } | 224 } |
230 | 225 |
231 TEST_F(FileSystemProviderRequestManagerTest, | 226 TEST_F(FileSystemProviderRequestManagerTest, |
232 CreateAndFulfillWithWrongRequestId) { | 227 CreateAndFulfillWithWrongRequestId) { |
233 EventLogger logger; | 228 EventLogger logger; |
234 | 229 |
235 int request_id = request_manager_->CreateRequest( | 230 int request_id = request_manager_->CreateRequest( |
236 file_system, | 231 kExtensionId, |
| 232 kFileSystemId, |
237 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | 233 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), |
238 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | 234 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); |
239 | 235 |
240 EXPECT_EQ(1, request_id); | 236 EXPECT_EQ(1, request_id); |
241 EXPECT_EQ(0u, logger.success_events().size()); | 237 EXPECT_EQ(0u, logger.success_events().size()); |
242 EXPECT_EQ(0u, logger.error_events().size()); | 238 EXPECT_EQ(0u, logger.error_events().size()); |
243 | 239 |
244 base::File::Error error = base::File::FILE_ERROR_NO_MEMORY; | 240 base::File::Error error = base::File::FILE_ERROR_NO_MEMORY; |
245 bool result = | 241 bool result = request_manager_->RejectRequest( |
246 request_manager_->RejectRequest(file_system, request_id + 1, error); | 242 kExtensionId, kFileSystemId, request_id + 1, error); |
247 EXPECT_FALSE(result); | 243 EXPECT_FALSE(result); |
248 | 244 |
249 // Callbacks should not be called. | 245 // Callbacks should not be called. |
250 EXPECT_EQ(0u, logger.error_events().size()); | 246 EXPECT_EQ(0u, logger.error_events().size()); |
251 EXPECT_EQ(0u, logger.success_events().size()); | 247 EXPECT_EQ(0u, logger.success_events().size()); |
252 | 248 |
253 // Confirm, that the request hasn't been removed, by rejecting it correctly. | 249 // Confirm, that the request hasn't been removed, by rejecting it correctly. |
254 { | 250 { |
255 bool retry = | 251 bool retry = request_manager_->RejectRequest( |
256 request_manager_->RejectRequest(file_system, request_id, error); | 252 kExtensionId, kFileSystemId, request_id, error); |
257 EXPECT_TRUE(retry); | 253 EXPECT_TRUE(retry); |
258 } | 254 } |
259 } | 255 } |
260 | 256 |
261 TEST_F(FileSystemProviderRequestManagerTest, | 257 TEST_F(FileSystemProviderRequestManagerTest, |
262 CreateAndRejectWithWrongRequestId) { | 258 CreateAndRejectWithWrongRequestId) { |
263 EventLogger logger; | 259 EventLogger logger; |
264 | 260 |
265 int request_id = request_manager_->CreateRequest( | 261 int request_id = request_manager_->CreateRequest( |
266 file_system, | 262 kExtensionId, |
| 263 kFileSystemId, |
267 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | 264 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), |
268 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | 265 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); |
269 | 266 |
270 EXPECT_EQ(1, request_id); | 267 EXPECT_EQ(1, request_id); |
271 EXPECT_EQ(0u, logger.success_events().size()); | 268 EXPECT_EQ(0u, logger.success_events().size()); |
272 EXPECT_EQ(0u, logger.error_events().size()); | 269 EXPECT_EQ(0u, logger.error_events().size()); |
273 | 270 |
274 base::File::Error error = base::File::FILE_ERROR_NO_MEMORY; | 271 base::File::Error error = base::File::FILE_ERROR_NO_MEMORY; |
275 bool result = | 272 bool result = request_manager_->RejectRequest( |
276 request_manager_->RejectRequest(file_system, request_id + 1, error); | 273 kExtensionId, kFileSystemId, request_id + 1, error); |
277 EXPECT_FALSE(result); | 274 EXPECT_FALSE(result); |
278 | 275 |
279 // Callbacks should not be called. | 276 // Callbacks should not be called. |
280 EXPECT_EQ(0u, logger.error_events().size()); | 277 EXPECT_EQ(0u, logger.error_events().size()); |
281 EXPECT_EQ(0u, logger.success_events().size()); | 278 EXPECT_EQ(0u, logger.success_events().size()); |
282 | 279 |
283 // Confirm, that the request hasn't been removed, by rejecting it correctly. | 280 // Confirm, that the request hasn't been removed, by rejecting it correctly. |
284 { | 281 { |
285 bool retry = | 282 bool retry = request_manager_->RejectRequest( |
286 request_manager_->RejectRequest(file_system, request_id, error); | 283 kExtensionId, kFileSystemId, request_id, error); |
287 EXPECT_TRUE(retry); | 284 EXPECT_TRUE(retry); |
288 } | 285 } |
289 } | 286 } |
290 | 287 |
291 TEST_F(FileSystemProviderRequestManagerTest, | 288 TEST_F(FileSystemProviderRequestManagerTest, |
292 CreateAndFulfillWithUnownedRequestId) { | 289 CreateAndFulfillWithUnownedRequestId) { |
293 EventLogger logger; | 290 EventLogger logger; |
294 | 291 |
295 int request_id = request_manager_->CreateRequest( | 292 int request_id = request_manager_->CreateRequest( |
296 file_system, | 293 kExtensionId, |
| 294 kFileSystemId, |
297 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | 295 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), |
298 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | 296 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); |
299 EXPECT_EQ(1, request_id); | 297 EXPECT_EQ(1, request_id); |
300 | 298 |
301 // Create another file system, which has just a different fiel system id | |
302 // (1 -> 2). | |
303 ProvidedFileSystem another_file_system( | |
304 kExtensionId, | |
305 2, // file_system_id | |
306 "Music", | |
307 base::FilePath::FromUTF8Unsafe( | |
308 "/provided/mbflcebpggnecokmikipoihdbecnjfoj-2-testing_profile-hash")); | |
309 | |
310 scoped_ptr<base::DictionaryValue> response; | 299 scoped_ptr<base::DictionaryValue> response; |
311 const bool has_next = false; | 300 const bool has_next = false; |
312 | 301 |
313 bool result = request_manager_->FulfillRequest( | 302 bool result = request_manager_->FulfillRequest(kExtensionId, |
314 another_file_system, request_id, response.Pass(), has_next); | 303 2, // file_system_id |
| 304 request_id, |
| 305 response.Pass(), |
| 306 has_next); |
315 EXPECT_FALSE(result); | 307 EXPECT_FALSE(result); |
316 | 308 |
317 // Callbacks should not be called. | 309 // Callbacks should not be called. |
318 EXPECT_EQ(0u, logger.error_events().size()); | 310 EXPECT_EQ(0u, logger.error_events().size()); |
319 EXPECT_EQ(0u, logger.success_events().size()); | 311 EXPECT_EQ(0u, logger.success_events().size()); |
320 | 312 |
321 // Confirm, that the request hasn't been removed, by fulfilling it again, but | 313 // Confirm, that the request hasn't been removed, by fulfilling it again, but |
322 // with a correct file system. | 314 // with a correct file system. |
323 { | 315 { |
324 bool retry = request_manager_->FulfillRequest( | 316 bool retry = request_manager_->FulfillRequest( |
325 file_system, request_id, response.Pass(), has_next); | 317 kExtensionId, kFileSystemId, request_id, response.Pass(), has_next); |
326 EXPECT_TRUE(retry); | 318 EXPECT_TRUE(retry); |
327 } | 319 } |
328 } | 320 } |
329 | 321 |
330 TEST_F(FileSystemProviderRequestManagerTest, UniqueIds) { | 322 TEST_F(FileSystemProviderRequestManagerTest, UniqueIds) { |
331 EventLogger logger; | 323 EventLogger logger; |
332 | 324 |
333 int first_request_id = request_manager_->CreateRequest( | 325 int first_request_id = request_manager_->CreateRequest( |
334 file_system, | 326 kExtensionId, |
| 327 kFileSystemId, |
335 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | 328 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), |
336 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | 329 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); |
337 | 330 |
338 int second_request_id = request_manager_->CreateRequest( | 331 int second_request_id = request_manager_->CreateRequest( |
339 file_system, | 332 kExtensionId, |
| 333 kFileSystemId, |
340 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), | 334 base::Bind(&EventLogger::OnSuccess, logger.GetWeakPtr()), |
341 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); | 335 base::Bind(&EventLogger::OnError, logger.GetWeakPtr())); |
342 | 336 |
343 EXPECT_EQ(1, first_request_id); | 337 EXPECT_EQ(1, first_request_id); |
344 EXPECT_EQ(2, second_request_id); | 338 EXPECT_EQ(2, second_request_id); |
345 } | 339 } |
346 | 340 |
347 } // namespace file_system_provider | 341 } // namespace file_system_provider |
348 } // namespace chromeos | 342 } // namespace chromeos |
OLD | NEW |