1 // Copyright 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "content/child/fileapi/webfilewriter_base.h" 6 7 #include "base/logging.h" 8 #include "base/memory/scoped_ptr.h" 9 #include "base/message_loop/message_loop.h" 10 #include "base/strings/utf_string_conversions.h" 11 #include "testing/gtest/include/gtest/gtest.h" 12 #include "third_party/WebKit/public/platform/WebFileError.h" 13 #include "third_party/WebKit/public/platform/WebFileWriterClient.h" 14 #include "third_party/WebKit/public/platform/WebURL.h" 15 #include "url/gurl.h" 16 17 namespace content { 18 19 namespace { 20 21 // We use particular offsets to trigger particular behaviors 22 // in the TestableFileWriter. 23 const int kNoOffset = -1; 24 const int kBasicFileTruncate_Offset = 1; 25 const int kErrorFileTruncate_Offset = 2; 26 const int kCancelFileTruncate_Offset = 3; 27 const int kCancelFailedTruncate_Offset = 4; 28 const int kBasicFileWrite_Offset = 1; 29 const int kErrorFileWrite_Offset = 2; 30 const int kMultiFileWrite_Offset = 3; 31 const int kCancelFileWriteBeforeCompletion_Offset = 4; 32 const int kCancelFileWriteAfterCompletion_Offset = 5; 33 34 GURL mock_path_as_gurl() { 35 return GURL("MockPath"); 36 } 37 38 } // namespace 39 40 class TestableFileWriter : public WebFileWriterBase { 41 public: 42 explicit TestableFileWriter(blink::WebFileWriterClient* client) 43 : WebFileWriterBase(mock_path_as_gurl(), client) { 44 reset(); 45 } 46 47 void reset() { 48 received_truncate_ = false; 49 received_truncate_path_ = GURL(); 50 received_truncate_offset_ = kNoOffset; 51 received_write_ = false; 52 received_write_path_ = GURL(); 53 received_write_offset_ = kNoOffset; 54 received_write_blob_uuid_ = std::string(); 55 received_cancel_ = false; 56 } 57 58 bool received_truncate_; 59 GURL received_truncate_path_; 60 int64 received_truncate_offset_; 61 bool received_write_; 62 GURL received_write_path_; 63 std::string received_write_blob_uuid_; 64 int64 received_write_offset_; 65 bool received_cancel_; 66 67 protected: 68 virtual void DoTruncate(const GURL& path, int64 offset) OVERRIDE { 69 received_truncate_ = true; 70 received_truncate_path_ = path; 71 received_truncate_offset_ = offset; 72 73 if (offset == kBasicFileTruncate_Offset) { 74 DidSucceed(); 75 } else if (offset == kErrorFileTruncate_Offset) { 76 DidFail(base::File::FILE_ERROR_NOT_FOUND); 77 } else if (offset == kCancelFileTruncate_Offset) { 78 cancel(); 79 DidSucceed(); // truncate completion 80 DidSucceed(); // cancel completion 81 } else if (offset == kCancelFailedTruncate_Offset) { 82 cancel(); 83 DidFail(base::File::FILE_ERROR_NOT_FOUND); // truncate completion 84 DidSucceed(); // cancel completion 85 } else { 86 FAIL(); 87 } 88 } 89 90 virtual void DoWrite( 91 const GURL& path, const std::string& blob_uuid, 92 int64 offset) OVERRIDE { 93 received_write_ = true; 94 received_write_path_ = path; 95 received_write_offset_ = offset; 96 received_write_blob_uuid_ = blob_uuid; 97 98 if (offset == kBasicFileWrite_Offset) { 99 DidWrite(1, true); 100 } else if (offset == kErrorFileWrite_Offset) { 101 DidFail(base::File::FILE_ERROR_NOT_FOUND); 102 } else if (offset == kMultiFileWrite_Offset) { 103 DidWrite(1, false); 104 DidWrite(1, false); 105 DidWrite(1, true); 106 } else if (offset == kCancelFileWriteBeforeCompletion_Offset) { 107 DidWrite(1, false); 108 cancel(); 109 DidWrite(1, false); 110 DidWrite(1, false); 111 DidFail(base::File::FILE_ERROR_FAILED); // write completion 112 DidSucceed(); // cancel completion 113 } else if (offset == kCancelFileWriteAfterCompletion_Offset) { 114 DidWrite(1, false); 115 cancel(); 116 DidWrite(1, false); 117 DidWrite(1, false); 118 DidWrite(1, true); // write completion 119 DidFail(base::File::FILE_ERROR_FAILED); // cancel completion 120 } else { 121 FAIL(); 122 } 123 } 124 125 virtual void DoCancel() OVERRIDE { 126 received_cancel_ = true; 127 } 128 }; 129 130 class FileWriterTest : public testing::Test, 131 public blink::WebFileWriterClient { 132 public: 133 FileWriterTest() { 134 reset(); 135 } 136 137 blink::WebFileWriter* writer() { 138 return testable_writer_.get(); 139 } 140 141 // WebFileWriterClient overrides 142 virtual void didWrite(long long bytes, bool complete) { 143 EXPECT_FALSE(received_did_write_complete_); 144 ++received_did_write_count_; 145 received_did_write_bytes_total_ += bytes; 146 if (complete) 147 received_did_write_complete_ = true; 148 149 if (delete_in_client_callback_) 150 testable_writer_.reset(NULL); 151 } 152 153 virtual void didTruncate() { 154 EXPECT_FALSE(received_did_truncate_); 155 received_did_truncate_ = true; 156 if (delete_in_client_callback_) 157 testable_writer_.reset(NULL); 158 } 159 160 virtual void didFail(blink::WebFileError error) { 161 EXPECT_FALSE(received_did_fail_); 162 received_did_fail_ = true; 163 fail_error_received_ = error; 164 if (delete_in_client_callback_) 165 testable_writer_.reset(NULL); 166 } 167 168 protected: 169 void reset() { 170 testable_writer_.reset(new TestableFileWriter(this)); 171 delete_in_client_callback_ = false; 172 received_did_write_count_ = 0; 173 received_did_write_bytes_total_ = 0; 174 received_did_write_complete_ = false; 175 received_did_truncate_ = false; 176 received_did_fail_ = false; 177 fail_error_received_ = static_cast<blink::WebFileError>(0); 178 } 179 180 scoped_ptr<TestableFileWriter> testable_writer_; 181 bool delete_in_client_callback_; 182 183 // Observed WebFileWriterClient artifacts. 184 int received_did_write_count_; 185 long long received_did_write_bytes_total_; 186 bool received_did_write_complete_; 187 bool received_did_truncate_; 188 bool received_did_fail_; 189 blink::WebFileError fail_error_received_; 190 191 DISALLOW_COPY_AND_ASSIGN(FileWriterTest); 192 }; 193 194 TEST_F(FileWriterTest, BasicFileWrite) { 195 // Call the webkit facing api. 196 const std::string kBlobId("1234"); 197 writer()->write(kBasicFileWrite_Offset, 198 blink::WebString::fromUTF8(kBlobId)); 199 200 // Check that the derived class gets called correctly. 201 EXPECT_TRUE(testable_writer_->received_write_); 202 EXPECT_EQ(testable_writer_->received_write_path_, 203 mock_path_as_gurl()); 204 EXPECT_EQ(kBasicFileWrite_Offset, 205 testable_writer_->received_write_offset_); 206 EXPECT_EQ(kBlobId, testable_writer_->received_write_blob_uuid_); 207 EXPECT_FALSE(testable_writer_->received_truncate_); 208 EXPECT_FALSE(testable_writer_->received_cancel_); 209 210 // Check that the client gets called correctly. 211 EXPECT_EQ(1, received_did_write_count_); 212 EXPECT_TRUE(received_did_write_complete_); 213 EXPECT_EQ(1, received_did_write_bytes_total_); 214 EXPECT_FALSE(received_did_truncate_); 215 EXPECT_FALSE(received_did_fail_); 216 } 217 218 TEST_F(FileWriterTest, BasicFileTruncate) { 219 // Call the webkit facing api. 220 writer()->truncate(kBasicFileTruncate_Offset); 221 222 // Check that the derived class gets called correctly. 223 EXPECT_TRUE(testable_writer_->received_truncate_); 224 EXPECT_EQ(mock_path_as_gurl(), 225 testable_writer_->received_truncate_path_); 226 EXPECT_EQ(kBasicFileTruncate_Offset, 227 testable_writer_->received_truncate_offset_); 228 EXPECT_FALSE(testable_writer_->received_write_); 229 EXPECT_FALSE(testable_writer_->received_cancel_); 230 231 // Check that the client gets called correctly. 232 EXPECT_TRUE(received_did_truncate_); 233 EXPECT_EQ(0, received_did_write_count_); 234 EXPECT_FALSE(received_did_fail_); 235 } 236 237 TEST_F(FileWriterTest, ErrorFileWrite) { 238 // Call the webkit facing api. 239 const std::string kBlobId("1234"); 240 writer()->write(kErrorFileWrite_Offset, 241 blink::WebString::fromUTF8(kBlobId)); 242 243 // Check that the derived class gets called correctly. 244 EXPECT_TRUE(testable_writer_->received_write_); 245 EXPECT_EQ(testable_writer_->received_write_path_, 246 mock_path_as_gurl()); 247 EXPECT_EQ(kErrorFileWrite_Offset, 248 testable_writer_->received_write_offset_); 249 EXPECT_EQ(kBlobId, testable_writer_->received_write_blob_uuid_); 250 EXPECT_FALSE(testable_writer_->received_truncate_); 251 EXPECT_FALSE(testable_writer_->received_cancel_); 252 253 // Check that the client gets called correctly. 254 EXPECT_TRUE(received_did_fail_); 255 EXPECT_EQ(blink::WebFileErrorNotFound, fail_error_received_); 256 EXPECT_EQ(0, received_did_write_count_); 257 EXPECT_FALSE(received_did_truncate_); 258 } 259 260 TEST_F(FileWriterTest, ErrorFileTruncate) { 261 // Call the webkit facing api. 262 writer()->truncate(kErrorFileTruncate_Offset); 263 264 // Check that the derived class gets called correctly. 265 EXPECT_TRUE(testable_writer_->received_truncate_); 266 EXPECT_EQ(mock_path_as_gurl(), 267 testable_writer_->received_truncate_path_); 268 EXPECT_EQ(kErrorFileTruncate_Offset, 269 testable_writer_->received_truncate_offset_); 270 EXPECT_FALSE(testable_writer_->received_write_); 271 EXPECT_FALSE(testable_writer_->received_cancel_); 272 273 // Check that the client gets called correctly. 274 EXPECT_TRUE(received_did_fail_); 275 EXPECT_EQ(blink::WebFileErrorNotFound, fail_error_received_); 276 EXPECT_FALSE(received_did_truncate_); 277 EXPECT_EQ(0, received_did_write_count_); 278 } 279 280 TEST_F(FileWriterTest, MultiFileWrite) { 281 // Call the webkit facing api. 282 const std::string kBlobId("1234"); 283 writer()->write(kMultiFileWrite_Offset, 284 blink::WebString::fromUTF8(kBlobId)); 285 286 // Check that the derived class gets called correctly. 287 EXPECT_TRUE(testable_writer_->received_write_); 288 EXPECT_EQ(testable_writer_->received_write_path_, 289 mock_path_as_gurl()); 290 EXPECT_EQ(kMultiFileWrite_Offset, 291 testable_writer_->received_write_offset_); 292 EXPECT_EQ(kBlobId, testable_writer_->received_write_blob_uuid_); 293 EXPECT_FALSE(testable_writer_->received_truncate_); 294 EXPECT_FALSE(testable_writer_->received_cancel_); 295 296 // Check that the client gets called correctly. 297 EXPECT_EQ(3, received_did_write_count_); 298 EXPECT_TRUE(received_did_write_complete_); 299 EXPECT_EQ(3, received_did_write_bytes_total_); 300 EXPECT_FALSE(received_did_truncate_); 301 EXPECT_FALSE(received_did_fail_); 302 } 303 304 TEST_F(FileWriterTest, CancelFileWriteBeforeCompletion) { 305 // Call the webkit facing api. 306 const std::string kBlobId("1234"); 307 writer()->write(kCancelFileWriteBeforeCompletion_Offset, 308 blink::WebString::fromUTF8(kBlobId)); 309 310 // Check that the derived class gets called correctly. 311 EXPECT_TRUE(testable_writer_->received_write_); 312 EXPECT_EQ(testable_writer_->received_write_path_, 313 mock_path_as_gurl()); 314 EXPECT_EQ(kCancelFileWriteBeforeCompletion_Offset, 315 testable_writer_->received_write_offset_); 316 EXPECT_EQ(kBlobId, testable_writer_->received_write_blob_uuid_); 317 EXPECT_TRUE(testable_writer_->received_cancel_); 318 EXPECT_FALSE(testable_writer_->received_truncate_); 319 320 // Check that the client gets called correctly. 321 EXPECT_TRUE(received_did_fail_); 322 EXPECT_EQ(blink::WebFileErrorAbort, fail_error_received_); 323 EXPECT_EQ(1, received_did_write_count_); 324 EXPECT_FALSE(received_did_write_complete_); 325 EXPECT_EQ(1, received_did_write_bytes_total_); 326 EXPECT_FALSE(received_did_truncate_); 327 } 328 329 TEST_F(FileWriterTest, CancelFileWriteAfterCompletion) { 330 // Call the webkit facing api. 331 const std::string kBlobId("1234"); 332 writer()->write(kCancelFileWriteAfterCompletion_Offset, 333 blink::WebString::fromUTF8(kBlobId)); 334 335 // Check that the derived class gets called correctly. 336 EXPECT_TRUE(testable_writer_->received_write_); 337 EXPECT_EQ(testable_writer_->received_write_path_, 338 mock_path_as_gurl()); 339 EXPECT_EQ(kCancelFileWriteAfterCompletion_Offset, 340 testable_writer_->received_write_offset_); 341 EXPECT_EQ(kBlobId, testable_writer_->received_write_blob_uuid_); 342 EXPECT_TRUE(testable_writer_->received_cancel_); 343 EXPECT_FALSE(testable_writer_->received_truncate_); 344 345 // Check that the client gets called correctly. 346 EXPECT_TRUE(received_did_fail_); 347 EXPECT_EQ(blink::WebFileErrorAbort, fail_error_received_); 348 EXPECT_EQ(1, received_did_write_count_); 349 EXPECT_FALSE(received_did_write_complete_); 350 EXPECT_EQ(1, received_did_write_bytes_total_); 351 EXPECT_FALSE(received_did_truncate_); 352 } 353 354 TEST_F(FileWriterTest, CancelFileTruncate) { 355 // Call the webkit facing api. 356 writer()->truncate(kCancelFileTruncate_Offset); 357 358 // Check that the derived class gets called correctly. 359 EXPECT_TRUE(testable_writer_->received_truncate_); 360 EXPECT_EQ(mock_path_as_gurl(), 361 testable_writer_->received_truncate_path_); 362 EXPECT_EQ(kCancelFileTruncate_Offset, 363 testable_writer_->received_truncate_offset_); 364 EXPECT_TRUE(testable_writer_->received_cancel_); 365 EXPECT_FALSE(testable_writer_->received_write_); 366 367 // Check that the client gets called correctly. 368 EXPECT_TRUE(received_did_fail_); 369 EXPECT_EQ(blink::WebFileErrorAbort, fail_error_received_); 370 EXPECT_FALSE(received_did_truncate_); 371 EXPECT_EQ(0, received_did_write_count_); 372 } 373 374 TEST_F(FileWriterTest, CancelFailedTruncate) { 375 // Call the webkit facing api. 376 writer()->truncate(kCancelFailedTruncate_Offset); 377 378 // Check that the derived class gets called correctly. 379 EXPECT_TRUE(testable_writer_->received_truncate_); 380 EXPECT_EQ(mock_path_as_gurl(), 381 testable_writer_->received_truncate_path_); 382 EXPECT_EQ(kCancelFailedTruncate_Offset, 383 testable_writer_->received_truncate_offset_); 384 EXPECT_TRUE(testable_writer_->received_cancel_); 385 EXPECT_FALSE(testable_writer_->received_write_); 386 387 // Check that the client gets called correctly. 388 EXPECT_TRUE(received_did_fail_); 389 EXPECT_EQ(blink::WebFileErrorAbort, fail_error_received_); 390 EXPECT_FALSE(received_did_truncate_); 391 EXPECT_EQ(0, received_did_write_count_); 392 } 393 394 TEST_F(FileWriterTest, DeleteInCompletionCallbacks) { 395 const std::string kBlobId("1234"); 396 delete_in_client_callback_ = true; 397 writer()->write(kBasicFileWrite_Offset, 398 blink::WebString::fromUTF8(kBlobId)); 399 EXPECT_FALSE(testable_writer_.get()); 400 401 reset(); 402 delete_in_client_callback_ = true; 403 writer()->truncate(kBasicFileTruncate_Offset); 404 EXPECT_FALSE(testable_writer_.get()); 405 406 reset(); 407 delete_in_client_callback_ = true; 408 writer()->write(kErrorFileWrite_Offset, 409 blink::WebString::fromUTF8(kBlobId)); 410 EXPECT_FALSE(testable_writer_.get()); 411 412 reset(); 413 delete_in_client_callback_ = true; 414 writer()->truncate(kErrorFileTruncate_Offset); 415 EXPECT_FALSE(testable_writer_.get()); 416 417 // Not crashing counts as passing. 418 } 419 420 } // namespace content 421
