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