Chromium Blob hacking

content/child/fileapi/webfilewriter_base_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/child/fileapi/webfilewriter_base.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 34 matching lines @@
   }
 
   void reset() {
     received_truncate_ = false;
     received_truncate_path_ = GURL();
     received_truncate_offset_ = kNoOffset;
     received_write_ = false;
     received_write_path_ = GURL();
     received_write_offset_ = kNoOffset;
     received_write_blob_url_ = GURL();
+    received_write_blob_uuid_ = std::string();
     received_cancel_ = false;
   }
 
   bool received_truncate_;
   GURL received_truncate_path_;
   int64 received_truncate_offset_;
   bool received_write_;
   GURL received_write_path_;
   GURL received_write_blob_url_;
+  std::string received_write_blob_uuid_;
   int64 received_write_offset_;
   bool received_cancel_;
 
  protected:
   virtual void DoTruncate(const GURL& path, int64 offset) OVERRIDE {
     received_truncate_ = true;
     received_truncate_path_ = path;
     received_truncate_offset_ = offset;
 
     if (offset == kBasicFileTruncate_Offset) {
       DidSucceed();
     } else if (offset == kErrorFileTruncate_Offset) {
       DidFail(base::PLATFORM_FILE_ERROR_NOT_FOUND);
     } else if (offset == kCancelFileTruncate_Offset) {
       cancel();
       DidSucceed();  // truncate completion
       DidSucceed();  // cancel completion
     } else if (offset == kCancelFailedTruncate_Offset) {
       cancel();
       DidFail(base::PLATFORM_FILE_ERROR_NOT_FOUND);  // truncate completion
       DidSucceed();  // cancel completion
     } else {
       FAIL();
     }
   }
 
-  virtual void DoWrite(const GURL& path, const GURL& blob_url,
-                       int64 offset) OVERRIDE {
+  virtual void DoWriteDeprecated(
+        const GURL& path, const GURL& blob_url,
+        int64 offset) OVERRIDE {
     received_write_ = true;
     received_write_path_ = path;
     received_write_offset_ = offset;
     received_write_blob_url_ = blob_url;
 
     if (offset == kBasicFileWrite_Offset) {
       DidWrite(1, true);
     } else if (offset == kErrorFileWrite_Offset) {
       DidFail(base::PLATFORM_FILE_ERROR_NOT_FOUND);
     } else if (offset == kMultiFileWrite_Offset) {
@@ skipping 12 matching lines @@
       cancel();
       DidWrite(1, false);
       DidWrite(1, false);
       DidWrite(1, true);  // write completion
       DidFail(base::PLATFORM_FILE_ERROR_FAILED);  // cancel completion
     } else {
       FAIL();
     }
   }
 
+  virtual void DoWrite(
+        const GURL& path, const std::string& blob_uuid,
+        int64 offset) OVERRIDE {
+    received_write_ = true;
+    received_write_path_ = path;
+    received_write_offset_ = offset;
+    received_write_blob_uuid_ = blob_uuid;
+
+    if (offset == kBasicFileWrite_Offset) {
+      DidWrite(1, true);
+    } else if (offset == kErrorFileWrite_Offset) {
+      DidFail(base::PLATFORM_FILE_ERROR_NOT_FOUND);
+    } else if (offset == kMultiFileWrite_Offset) {
+      DidWrite(1, false);
+      DidWrite(1, false);
+      DidWrite(1, true);
+    } else if (offset == kCancelFileWriteBeforeCompletion_Offset) {
+      DidWrite(1, false);
+      cancel();
+      DidWrite(1, false);
+      DidWrite(1, false);
+      DidFail(base::PLATFORM_FILE_ERROR_FAILED);  // write completion
+      DidSucceed();  // cancel completion
+    } else if (offset == kCancelFileWriteAfterCompletion_Offset) {
+      DidWrite(1, false);
+      cancel();
+      DidWrite(1, false);
+      DidWrite(1, false);
+      DidWrite(1, true);  // write completion
+      DidFail(base::PLATFORM_FILE_ERROR_FAILED);  // cancel completion
+    } else {
+      FAIL();
+    }
+  }
+
   virtual void DoCancel() OVERRIDE {
     received_cancel_ = true;
   }
 };
 
 class FileWriterTest : public testing::Test,
                        public WebKit::WebFileWriterClient {
  public:
   FileWriterTest() {
     reset();
@@ skipping 49 matching lines @@
   int received_did_write_count_;
   long long received_did_write_bytes_total_;
   bool received_did_write_complete_;
   bool received_did_truncate_;
   bool received_did_fail_;
   WebKit::WebFileError fail_error_received_;
 
   DISALLOW_COPY_AND_ASSIGN(FileWriterTest);
 };
 
+
+// TODO(michaeln): update the tests to once webkit api is updated.

[ericu, 2013/08/21 23:26:09]

to what?

[michaeln, 2013/08/27 23:24:06]

added a link to the bug

[ericu, 2013/08/28 22:01:28]

Still "update the tests to"...to what?
Oh, do you mean "too"?

[michaeln, 2013/08/28 22:54:47]

Yes, i meant "too" (or just botched the sentence). The write() method call that
takes a blobUrl as input is going away soon.

+
 TEST_F(FileWriterTest, BasicFileWrite) {
   // Call the webkit facing api.
   const GURL kBlobUrl("blob://bloburl/");
   writer()->write(kBasicFileWrite_Offset, kBlobUrl);
 
   // Check that the derived class gets called correctly.
   EXPECT_TRUE(testable_writer_->received_write_);
   EXPECT_EQ(testable_writer_->received_write_path_,
             mock_path_as_gurl());
   EXPECT_EQ(kBasicFileWrite_Offset,
@@ skipping 199 matching lines @@
 
   reset();
   delete_in_client_callback_ = true;
   writer()->truncate(kErrorFileTruncate_Offset);
   EXPECT_FALSE(testable_writer_.get());
 
   // Not crashing counts as passing.
 }
 
 }  // namespace content