OLD | NEW |
1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2013 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 "webkit/browser/fileapi/upload_file_system_file_element_reader.h" | 5 #include "webkit/browser/fileapi/upload_file_system_file_element_reader.h" |
6 | 6 |
7 #include "base/files/scoped_temp_dir.h" | 7 #include "base/files/scoped_temp_dir.h" |
8 #include "base/message_loop.h" | 8 #include "base/message_loop.h" |
9 #include "net/base/io_buffer.h" | 9 #include "net/base/io_buffer.h" |
10 #include "net/base/test_completion_callback.h" | 10 #include "net/base/test_completion_callback.h" |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
48 | 48 |
49 // Prepare a file on file system. | 49 // Prepare a file on file system. |
50 const char kTestData[] = "abcdefghijklmnop0123456789"; | 50 const char kTestData[] = "abcdefghijklmnop0123456789"; |
51 file_data_.assign(kTestData, kTestData + arraysize(kTestData) - 1); | 51 file_data_.assign(kTestData, kTestData + arraysize(kTestData) - 1); |
52 const char kFilename[] = "File.dat"; | 52 const char kFilename[] = "File.dat"; |
53 file_url_ = GetFileSystemURL(kFilename); | 53 file_url_ = GetFileSystemURL(kFilename); |
54 WriteFileSystemFile(kFilename, &file_data_[0], file_data_.size(), | 54 WriteFileSystemFile(kFilename, &file_data_[0], file_data_.size(), |
55 &file_modification_time_); | 55 &file_modification_time_); |
56 | 56 |
57 // Create and initialize a reader. | 57 // Create and initialize a reader. |
58 reader_.reset(new UploadFileSystemFileElementReader( | 58 reader_.reset( |
59 file_system_context_, file_url_, 0, kuint64max, | 59 new UploadFileSystemFileElementReader(file_system_context_.get(), |
60 file_modification_time_)); | 60 file_url_, |
| 61 0, |
| 62 kuint64max, |
| 63 file_modification_time_)); |
61 net::TestCompletionCallback callback; | 64 net::TestCompletionCallback callback; |
62 ASSERT_EQ(net::ERR_IO_PENDING, reader_->Init(callback.callback())); | 65 ASSERT_EQ(net::ERR_IO_PENDING, reader_->Init(callback.callback())); |
63 EXPECT_EQ(net::OK, callback.WaitForResult()); | 66 EXPECT_EQ(net::OK, callback.WaitForResult()); |
64 EXPECT_EQ(file_data_.size(), reader_->GetContentLength()); | 67 EXPECT_EQ(file_data_.size(), reader_->GetContentLength()); |
65 EXPECT_EQ(file_data_.size(), reader_->BytesRemaining()); | 68 EXPECT_EQ(file_data_.size(), reader_->BytesRemaining()); |
66 EXPECT_FALSE(reader_->IsInMemory()); | 69 EXPECT_FALSE(reader_->IsInMemory()); |
67 } | 70 } |
68 | 71 |
69 protected: | 72 protected: |
70 GURL GetFileSystemURL(const std::string& filename) { | 73 GURL GetFileSystemURL(const std::string& filename) { |
71 return GURL(file_system_root_url_.spec() + filename); | 74 return GURL(file_system_root_url_.spec() + filename); |
72 } | 75 } |
73 | 76 |
74 void WriteFileSystemFile(const std::string& filename, | 77 void WriteFileSystemFile(const std::string& filename, |
75 const char* buf, | 78 const char* buf, |
76 int buf_size, | 79 int buf_size, |
77 base::Time* modification_time) { | 80 base::Time* modification_time) { |
78 fileapi::FileSystemURL url = | 81 fileapi::FileSystemURL url = |
79 file_system_context_->CreateCrackedFileSystemURL( | 82 file_system_context_->CreateCrackedFileSystemURL( |
80 GURL(kFileSystemURLOrigin), | 83 GURL(kFileSystemURLOrigin), |
81 kFileSystemType, | 84 kFileSystemType, |
82 base::FilePath().AppendASCII(filename)); | 85 base::FilePath().AppendASCII(filename)); |
83 | 86 |
84 fileapi::FileSystemFileUtil* file_util = | 87 fileapi::FileSystemFileUtil* file_util = |
85 file_system_context_->GetFileUtil(kFileSystemType); | 88 file_system_context_->GetFileUtil(kFileSystemType); |
86 | 89 |
87 fileapi::FileSystemOperationContext context(file_system_context_); | 90 fileapi::FileSystemOperationContext context(file_system_context_.get()); |
88 context.set_allowed_bytes_growth(1024); | 91 context.set_allowed_bytes_growth(1024); |
89 | 92 |
90 base::PlatformFile handle = base::kInvalidPlatformFileValue; | 93 base::PlatformFile handle = base::kInvalidPlatformFileValue; |
91 bool created = false; | 94 bool created = false; |
92 ASSERT_EQ(base::PLATFORM_FILE_OK, file_util->CreateOrOpen( | 95 ASSERT_EQ(base::PLATFORM_FILE_OK, file_util->CreateOrOpen( |
93 &context, | 96 &context, |
94 url, | 97 url, |
95 base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_WRITE, | 98 base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_WRITE, |
96 &handle, | 99 &handle, |
97 &created)); | 100 &created)); |
(...skipping 26 matching lines...) Expand all Loading... |
124 std::vector<char> file_data_; | 127 std::vector<char> file_data_; |
125 GURL file_url_; | 128 GURL file_url_; |
126 base::Time file_modification_time_; | 129 base::Time file_modification_time_; |
127 scoped_ptr<UploadFileSystemFileElementReader> reader_; | 130 scoped_ptr<UploadFileSystemFileElementReader> reader_; |
128 }; | 131 }; |
129 | 132 |
130 TEST_F(UploadFileSystemFileElementReaderTest, ReadAll) { | 133 TEST_F(UploadFileSystemFileElementReaderTest, ReadAll) { |
131 scoped_refptr<net::IOBufferWithSize> buf = | 134 scoped_refptr<net::IOBufferWithSize> buf = |
132 new net::IOBufferWithSize(file_data_.size()); | 135 new net::IOBufferWithSize(file_data_.size()); |
133 net::TestCompletionCallback read_callback; | 136 net::TestCompletionCallback read_callback; |
134 ASSERT_EQ(net::ERR_IO_PENDING, reader_->Read(buf, buf->size(), | 137 ASSERT_EQ(net::ERR_IO_PENDING, |
135 read_callback.callback())); | 138 reader_->Read(buf.get(), buf->size(), read_callback.callback())); |
136 EXPECT_EQ(buf->size(), read_callback.WaitForResult()); | 139 EXPECT_EQ(buf->size(), read_callback.WaitForResult()); |
137 EXPECT_EQ(0U, reader_->BytesRemaining()); | 140 EXPECT_EQ(0U, reader_->BytesRemaining()); |
138 EXPECT_TRUE(std::equal(file_data_.begin(), file_data_.end(), buf->data())); | 141 EXPECT_TRUE(std::equal(file_data_.begin(), file_data_.end(), buf->data())); |
139 // Try to read again. | 142 // Try to read again. |
140 EXPECT_EQ(0, reader_->Read(buf, buf->size(), read_callback.callback())); | 143 EXPECT_EQ(0, reader_->Read(buf.get(), buf->size(), read_callback.callback())); |
141 } | 144 } |
142 | 145 |
143 TEST_F(UploadFileSystemFileElementReaderTest, ReadPartially) { | 146 TEST_F(UploadFileSystemFileElementReaderTest, ReadPartially) { |
144 const size_t kHalfSize = file_data_.size() / 2; | 147 const size_t kHalfSize = file_data_.size() / 2; |
145 ASSERT_EQ(file_data_.size(), kHalfSize * 2); | 148 ASSERT_EQ(file_data_.size(), kHalfSize * 2); |
146 | 149 |
147 scoped_refptr<net::IOBufferWithSize> buf = | 150 scoped_refptr<net::IOBufferWithSize> buf = |
148 new net::IOBufferWithSize(kHalfSize); | 151 new net::IOBufferWithSize(kHalfSize); |
149 | 152 |
150 net::TestCompletionCallback read_callback1; | 153 net::TestCompletionCallback read_callback1; |
151 ASSERT_EQ(net::ERR_IO_PENDING, reader_->Read(buf, buf->size(), | 154 ASSERT_EQ(net::ERR_IO_PENDING, |
152 read_callback1.callback())); | 155 reader_->Read(buf.get(), buf->size(), read_callback1.callback())); |
153 EXPECT_EQ(buf->size(), read_callback1.WaitForResult()); | 156 EXPECT_EQ(buf->size(), read_callback1.WaitForResult()); |
154 EXPECT_EQ(file_data_.size() - buf->size(), reader_->BytesRemaining()); | 157 EXPECT_EQ(file_data_.size() - buf->size(), reader_->BytesRemaining()); |
155 EXPECT_TRUE(std::equal(file_data_.begin(), file_data_.begin() + kHalfSize, | 158 EXPECT_TRUE(std::equal(file_data_.begin(), file_data_.begin() + kHalfSize, |
156 buf->data())); | 159 buf->data())); |
157 | 160 |
158 net::TestCompletionCallback read_callback2; | 161 net::TestCompletionCallback read_callback2; |
159 EXPECT_EQ(net::ERR_IO_PENDING, reader_->Read(buf, buf->size(), | 162 EXPECT_EQ(net::ERR_IO_PENDING, |
160 read_callback2.callback())); | 163 reader_->Read(buf.get(), buf->size(), read_callback2.callback())); |
161 EXPECT_EQ(buf->size(), read_callback2.WaitForResult()); | 164 EXPECT_EQ(buf->size(), read_callback2.WaitForResult()); |
162 EXPECT_EQ(0U, reader_->BytesRemaining()); | 165 EXPECT_EQ(0U, reader_->BytesRemaining()); |
163 EXPECT_TRUE(std::equal(file_data_.begin() + kHalfSize, file_data_.end(), | 166 EXPECT_TRUE(std::equal(file_data_.begin() + kHalfSize, file_data_.end(), |
164 buf->data())); | 167 buf->data())); |
165 } | 168 } |
166 | 169 |
167 TEST_F(UploadFileSystemFileElementReaderTest, ReadTooMuch) { | 170 TEST_F(UploadFileSystemFileElementReaderTest, ReadTooMuch) { |
168 const size_t kTooLargeSize = file_data_.size() * 2; | 171 const size_t kTooLargeSize = file_data_.size() * 2; |
169 scoped_refptr<net::IOBufferWithSize> buf = | 172 scoped_refptr<net::IOBufferWithSize> buf = |
170 new net::IOBufferWithSize(kTooLargeSize); | 173 new net::IOBufferWithSize(kTooLargeSize); |
171 net::TestCompletionCallback read_callback; | 174 net::TestCompletionCallback read_callback; |
172 ASSERT_EQ(net::ERR_IO_PENDING, reader_->Read(buf, buf->size(), | 175 ASSERT_EQ(net::ERR_IO_PENDING, |
173 read_callback.callback())); | 176 reader_->Read(buf.get(), buf->size(), read_callback.callback())); |
174 EXPECT_EQ(static_cast<int>(file_data_.size()), read_callback.WaitForResult()); | 177 EXPECT_EQ(static_cast<int>(file_data_.size()), read_callback.WaitForResult()); |
175 EXPECT_EQ(0U, reader_->BytesRemaining()); | 178 EXPECT_EQ(0U, reader_->BytesRemaining()); |
176 EXPECT_TRUE(std::equal(file_data_.begin(), file_data_.end(), buf->data())); | 179 EXPECT_TRUE(std::equal(file_data_.begin(), file_data_.end(), buf->data())); |
177 } | 180 } |
178 | 181 |
179 TEST_F(UploadFileSystemFileElementReaderTest, MultipleInit) { | 182 TEST_F(UploadFileSystemFileElementReaderTest, MultipleInit) { |
180 scoped_refptr<net::IOBufferWithSize> buf = | 183 scoped_refptr<net::IOBufferWithSize> buf = |
181 new net::IOBufferWithSize(file_data_.size()); | 184 new net::IOBufferWithSize(file_data_.size()); |
182 | 185 |
183 // Read all. | 186 // Read all. |
184 net::TestCompletionCallback read_callback1; | 187 net::TestCompletionCallback read_callback1; |
185 ASSERT_EQ(net::ERR_IO_PENDING, reader_->Read(buf, buf->size(), | 188 ASSERT_EQ(net::ERR_IO_PENDING, |
186 read_callback1.callback())); | 189 reader_->Read(buf.get(), buf->size(), read_callback1.callback())); |
187 EXPECT_EQ(buf->size(), read_callback1.WaitForResult()); | 190 EXPECT_EQ(buf->size(), read_callback1.WaitForResult()); |
188 EXPECT_EQ(0U, reader_->BytesRemaining()); | 191 EXPECT_EQ(0U, reader_->BytesRemaining()); |
189 EXPECT_TRUE(std::equal(file_data_.begin(), file_data_.end(), buf->data())); | 192 EXPECT_TRUE(std::equal(file_data_.begin(), file_data_.end(), buf->data())); |
190 | 193 |
191 // Call Init() again to reset the state. | 194 // Call Init() again to reset the state. |
192 net::TestCompletionCallback init_callback; | 195 net::TestCompletionCallback init_callback; |
193 ASSERT_EQ(net::ERR_IO_PENDING, reader_->Init(init_callback.callback())); | 196 ASSERT_EQ(net::ERR_IO_PENDING, reader_->Init(init_callback.callback())); |
194 EXPECT_EQ(net::OK, init_callback.WaitForResult()); | 197 EXPECT_EQ(net::OK, init_callback.WaitForResult()); |
195 EXPECT_EQ(file_data_.size(), reader_->GetContentLength()); | 198 EXPECT_EQ(file_data_.size(), reader_->GetContentLength()); |
196 EXPECT_EQ(file_data_.size(), reader_->BytesRemaining()); | 199 EXPECT_EQ(file_data_.size(), reader_->BytesRemaining()); |
197 | 200 |
198 // Read again. | 201 // Read again. |
199 net::TestCompletionCallback read_callback2; | 202 net::TestCompletionCallback read_callback2; |
200 ASSERT_EQ(net::ERR_IO_PENDING, reader_->Read(buf, buf->size(), | 203 ASSERT_EQ(net::ERR_IO_PENDING, |
201 read_callback2.callback())); | 204 reader_->Read(buf.get(), buf->size(), read_callback2.callback())); |
202 EXPECT_EQ(buf->size(), read_callback2.WaitForResult()); | 205 EXPECT_EQ(buf->size(), read_callback2.WaitForResult()); |
203 EXPECT_EQ(0U, reader_->BytesRemaining()); | 206 EXPECT_EQ(0U, reader_->BytesRemaining()); |
204 EXPECT_TRUE(std::equal(file_data_.begin(), file_data_.end(), buf->data())); | 207 EXPECT_TRUE(std::equal(file_data_.begin(), file_data_.end(), buf->data())); |
205 } | 208 } |
206 | 209 |
207 TEST_F(UploadFileSystemFileElementReaderTest, InitDuringAsyncOperation) { | 210 TEST_F(UploadFileSystemFileElementReaderTest, InitDuringAsyncOperation) { |
208 scoped_refptr<net::IOBufferWithSize> buf = | 211 scoped_refptr<net::IOBufferWithSize> buf = |
209 new net::IOBufferWithSize(file_data_.size()); | 212 new net::IOBufferWithSize(file_data_.size()); |
210 | 213 |
211 // Start reading all. | 214 // Start reading all. |
212 net::TestCompletionCallback read_callback1; | 215 net::TestCompletionCallback read_callback1; |
213 EXPECT_EQ(net::ERR_IO_PENDING, reader_->Read(buf, buf->size(), | 216 EXPECT_EQ(net::ERR_IO_PENDING, |
214 read_callback1.callback())); | 217 reader_->Read(buf.get(), buf->size(), read_callback1.callback())); |
215 | 218 |
216 // Call Init to cancel the previous read. | 219 // Call Init to cancel the previous read. |
217 net::TestCompletionCallback init_callback1; | 220 net::TestCompletionCallback init_callback1; |
218 EXPECT_EQ(net::ERR_IO_PENDING, reader_->Init(init_callback1.callback())); | 221 EXPECT_EQ(net::ERR_IO_PENDING, reader_->Init(init_callback1.callback())); |
219 | 222 |
220 // Call Init again to cancel the previous init. | 223 // Call Init again to cancel the previous init. |
221 net::TestCompletionCallback init_callback2; | 224 net::TestCompletionCallback init_callback2; |
222 EXPECT_EQ(net::ERR_IO_PENDING, reader_->Init(init_callback2.callback())); | 225 EXPECT_EQ(net::ERR_IO_PENDING, reader_->Init(init_callback2.callback())); |
223 EXPECT_EQ(net::OK, init_callback2.WaitForResult()); | 226 EXPECT_EQ(net::OK, init_callback2.WaitForResult()); |
224 EXPECT_EQ(file_data_.size(), reader_->GetContentLength()); | 227 EXPECT_EQ(file_data_.size(), reader_->GetContentLength()); |
225 EXPECT_EQ(file_data_.size(), reader_->BytesRemaining()); | 228 EXPECT_EQ(file_data_.size(), reader_->BytesRemaining()); |
226 | 229 |
227 // Read half. | 230 // Read half. |
228 scoped_refptr<net::IOBufferWithSize> buf2 = | 231 scoped_refptr<net::IOBufferWithSize> buf2 = |
229 new net::IOBufferWithSize(file_data_.size() / 2); | 232 new net::IOBufferWithSize(file_data_.size() / 2); |
230 net::TestCompletionCallback read_callback2; | 233 net::TestCompletionCallback read_callback2; |
231 EXPECT_EQ(net::ERR_IO_PENDING, reader_->Read(buf2, buf2->size(), | 234 EXPECT_EQ(net::ERR_IO_PENDING, |
232 read_callback2.callback())); | 235 reader_->Read(buf2.get(), buf2->size(), read_callback2.callback())); |
233 EXPECT_EQ(buf2->size(), read_callback2.WaitForResult()); | 236 EXPECT_EQ(buf2->size(), read_callback2.WaitForResult()); |
234 EXPECT_EQ(file_data_.size() - buf2->size(), reader_->BytesRemaining()); | 237 EXPECT_EQ(file_data_.size() - buf2->size(), reader_->BytesRemaining()); |
235 EXPECT_TRUE(std::equal(file_data_.begin(), file_data_.begin() + buf2->size(), | 238 EXPECT_TRUE(std::equal(file_data_.begin(), file_data_.begin() + buf2->size(), |
236 buf2->data())); | 239 buf2->data())); |
237 | 240 |
238 // Make sure callbacks are not called for cancelled operations. | 241 // Make sure callbacks are not called for cancelled operations. |
239 EXPECT_FALSE(read_callback1.have_result()); | 242 EXPECT_FALSE(read_callback1.have_result()); |
240 EXPECT_FALSE(init_callback1.have_result()); | 243 EXPECT_FALSE(init_callback1.have_result()); |
241 } | 244 } |
242 | 245 |
243 TEST_F(UploadFileSystemFileElementReaderTest, Range) { | 246 TEST_F(UploadFileSystemFileElementReaderTest, Range) { |
244 const int kOffset = 2; | 247 const int kOffset = 2; |
245 const int kLength = file_data_.size() - kOffset * 3; | 248 const int kLength = file_data_.size() - kOffset * 3; |
246 reader_.reset(new UploadFileSystemFileElementReader( | 249 reader_.reset(new UploadFileSystemFileElementReader( |
247 file_system_context_, file_url_, kOffset, kLength, base::Time())); | 250 file_system_context_.get(), file_url_, kOffset, kLength, base::Time())); |
248 net::TestCompletionCallback init_callback; | 251 net::TestCompletionCallback init_callback; |
249 ASSERT_EQ(net::ERR_IO_PENDING, reader_->Init(init_callback.callback())); | 252 ASSERT_EQ(net::ERR_IO_PENDING, reader_->Init(init_callback.callback())); |
250 EXPECT_EQ(net::OK, init_callback.WaitForResult()); | 253 EXPECT_EQ(net::OK, init_callback.WaitForResult()); |
251 EXPECT_EQ(static_cast<uint64>(kLength), reader_->GetContentLength()); | 254 EXPECT_EQ(static_cast<uint64>(kLength), reader_->GetContentLength()); |
252 EXPECT_EQ(static_cast<uint64>(kLength), reader_->BytesRemaining()); | 255 EXPECT_EQ(static_cast<uint64>(kLength), reader_->BytesRemaining()); |
253 scoped_refptr<net::IOBufferWithSize> buf = new net::IOBufferWithSize(kLength); | 256 scoped_refptr<net::IOBufferWithSize> buf = new net::IOBufferWithSize(kLength); |
254 net::TestCompletionCallback read_callback; | 257 net::TestCompletionCallback read_callback; |
255 ASSERT_EQ(net::ERR_IO_PENDING, reader_->Read(buf, buf->size(), | 258 ASSERT_EQ(net::ERR_IO_PENDING, |
256 read_callback.callback())); | 259 reader_->Read(buf.get(), buf->size(), read_callback.callback())); |
257 EXPECT_EQ(kLength, read_callback.WaitForResult()); | 260 EXPECT_EQ(kLength, read_callback.WaitForResult()); |
258 EXPECT_TRUE(std::equal(file_data_.begin() + kOffset, | 261 EXPECT_TRUE(std::equal(file_data_.begin() + kOffset, |
259 file_data_.begin() + kOffset + kLength, | 262 file_data_.begin() + kOffset + kLength, |
260 buf->data())); | 263 buf->data())); |
261 } | 264 } |
262 | 265 |
263 TEST_F(UploadFileSystemFileElementReaderTest, FileChanged) { | 266 TEST_F(UploadFileSystemFileElementReaderTest, FileChanged) { |
264 // Expect one second before the actual modification time to simulate change. | 267 // Expect one second before the actual modification time to simulate change. |
265 const base::Time expected_modification_time = | 268 const base::Time expected_modification_time = |
266 file_modification_time_ - base::TimeDelta::FromSeconds(1); | 269 file_modification_time_ - base::TimeDelta::FromSeconds(1); |
267 reader_.reset(new UploadFileSystemFileElementReader( | 270 reader_.reset( |
268 file_system_context_, file_url_, 0, kuint64max, | 271 new UploadFileSystemFileElementReader(file_system_context_.get(), |
269 expected_modification_time)); | 272 file_url_, |
| 273 0, |
| 274 kuint64max, |
| 275 expected_modification_time)); |
270 net::TestCompletionCallback init_callback; | 276 net::TestCompletionCallback init_callback; |
271 ASSERT_EQ(net::ERR_IO_PENDING, reader_->Init(init_callback.callback())); | 277 ASSERT_EQ(net::ERR_IO_PENDING, reader_->Init(init_callback.callback())); |
272 EXPECT_EQ(net::ERR_UPLOAD_FILE_CHANGED, init_callback.WaitForResult()); | 278 EXPECT_EQ(net::ERR_UPLOAD_FILE_CHANGED, init_callback.WaitForResult()); |
273 } | 279 } |
274 | 280 |
275 TEST_F(UploadFileSystemFileElementReaderTest, WrongURL) { | 281 TEST_F(UploadFileSystemFileElementReaderTest, WrongURL) { |
276 const GURL wrong_url = GetFileSystemURL("wrong_file_name.dat"); | 282 const GURL wrong_url = GetFileSystemURL("wrong_file_name.dat"); |
277 reader_.reset(new UploadFileSystemFileElementReader( | 283 reader_.reset(new UploadFileSystemFileElementReader( |
278 file_system_context_, wrong_url, 0, kuint64max, base::Time())); | 284 file_system_context_.get(), wrong_url, 0, kuint64max, base::Time())); |
279 net::TestCompletionCallback init_callback; | 285 net::TestCompletionCallback init_callback; |
280 ASSERT_EQ(net::ERR_IO_PENDING, reader_->Init(init_callback.callback())); | 286 ASSERT_EQ(net::ERR_IO_PENDING, reader_->Init(init_callback.callback())); |
281 EXPECT_EQ(net::ERR_FILE_NOT_FOUND, init_callback.WaitForResult()); | 287 EXPECT_EQ(net::ERR_FILE_NOT_FOUND, init_callback.WaitForResult()); |
282 } | 288 } |
283 | 289 |
284 } // namespace fileapi | 290 } // namespace fileapi |
OLD | NEW |