Sync Blob.close() behavior wrt updated spec.

The File API now defines Blobs as having a readability state of
opened/closed, http://dev.w3.org/2006/webapi/FileAPI/#readabilityState
With close() naturally making the Blob enter the 'closed' state,

  http://dev.w3.org/2006/webapi/FileAPI/#close-method

Like the FileReader operations, Blob methods will now throw
InvalidStateError when passed a Blob in such a 'closed' state.

Update the implementation to follow the spec.

R=kinuko@chromium.org
BUG=344820

Review URL: https://codereview.chromium.org/184473002

git-svn-id: svn://svn.chromium.org/blink/trunk@168567 bbb929c8-8fbe-4397-9dbb-9b2b20218538

third_party/WebKit/LayoutTests/fast/files/blob-close-expected.txt

@@ -12,6 +12,8 @@ PASS blob.close(); blob.size is 0
 PASS blob.type is "text/plain"
 PASS sliced1.size is 3
 PASS sliced2.size is 1
+PASS blob.slice(2) threw exception InvalidStateError: Failed to execute 'slice' on 'Blob': Blob has been closed..
+PASS blob.close() threw exception InvalidStateError: Failed to execute 'close' on 'Blob': Blob has been closed..
 PASS successfullyParsed is true
 
 TEST COMPLETE

third_party/WebKit/LayoutTests/fast/files/blob-close-revoke-expected.txt

@@ -17,8 +17,7 @@ PASS Error triggered on starting Worker from a closed Blob.
 PASS Error triggered on starting Worker from a closed Blob.
 PASS Error triggered on starting Worker from a closed Blob.
 Test creating object URLs on closed Blobs
-PASS blobURL1 !== blobURL2 is true
-PASS blobURL2.length > 0 is true
+PASS window.URL.createObjectURL(blob); threw exception InvalidStateError: Failed to execute 'createObjectURL' on 'URL': Blob has been closed..
 PASS successfullyParsed is true
 
 TEST COMPLETE

third_party/WebKit/LayoutTests/fast/files/blob-close-revoke.html

@@ -91,24 +91,19 @@ function testRevokeAfterClose()
     img.src = blobURL1;
 }
 
-function testRegisterAfterClose()
+function testCreateAfterClose()
 {
     debug("Test creating object URLs on closed Blobs");
     blob = new Blob(["body{background: green}"], {type: "text/css"});
-    blobURL1 = window.URL.createObjectURL(blob);
     blob.close();
-    // Verifies createObjectURL() still works and returns a valid (non-empty) URL
-    // without throwing an error. See http://crbug.com/344820 for this requirement.
-    blobURL2 = window.URL.createObjectURL(blob);
-    shouldBeTrue("blobURL1 !== blobURL2");
-    shouldBeTrue("blobURL2.length > 0");
+    shouldThrow("window.URL.createObjectURL(blob);");
     runNextTest();
 }
 
 var tests = [
     testRevokeAfterClose,
     testRevokeAfterCloseWorkers,
-    testRegisterAfterClose ];
+    testCreateAfterClose ];
 
 function runNextTest()
 {

third_party/WebKit/LayoutTests/fast/files/blob-close.html

@@ -19,4 +19,6 @@ shouldBeEqualToString("blob.type", "text/plain");
 shouldBe("sliced1.size", "3");
 var sliced2 = sliced1.slice(2);
 shouldBe("sliced2.size", "1");
+shouldThrow("blob.slice(2)");
+shouldThrow("blob.close()");
 </script>

third_party/WebKit/Source/core/dom/DOMURL.cpp

@@ -63,10 +63,14 @@ void DOMURL::setInput(const String& value)
     }
 }
 
-String DOMURL::createObjectURL(ExecutionContext* executionContext, Blob* blob)
+String DOMURL::createObjectURL(ExecutionContext* executionContext, Blob* blob, ExceptionState& exceptionState)
 {
     if (!executionContext || !blob)
         return String();
+    if (blob->hasBeenClosed()) {
+        exceptionState.throwDOMException(InvalidStateError, String(blob->isFile() ? "File" : "Blob") + " has been closed.");
+        return String();
+    }
     return createPublicURL(executionContext, blob, blob->uuid());
 }
 

third_party/WebKit/Source/core/dom/DOMURL.h

@@ -59,7 +59,7 @@ public:
         return adoptRefWillBeNoop(new DOMURL(url, base->m_url, exceptionState));
     }
 
-    static String createObjectURL(ExecutionContext*, Blob*);
+    static String createObjectURL(ExecutionContext*, Blob*, ExceptionState&);
     static void revokeObjectURL(ExecutionContext*, const String&);
 
     static String createPublicURL(ExecutionContext*, URLRegistrable*, const String& uuid = String());

third_party/WebKit/Source/core/dom/URL.idl

@@ -33,7 +33,7 @@
     ImplementedAs=DOMURL,
     WillBeGarbageCollected
 ] interface URL {
-    [CallWith=ExecutionContext,TreatReturnedNullStringAs=Null] static DOMString createObjectURL(Blob? blob);
+    [RaisesException, CallWith=ExecutionContext,TreatReturnedNullStringAs=Null] static DOMString createObjectURL(Blob? blob);
     [CallWith=ExecutionContext] static void revokeObjectURL(DOMString url);
 };
 

third_party/WebKit/Source/core/fileapi/Blob.cpp

@@ -31,7 +31,9 @@
 #include "config.h"
 #include "core/fileapi/Blob.h"
 
+#include "bindings/v8/ExceptionState.h"
 #include "core/dom/DOMURL.h"
+#include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/fileapi/File.h"
 #include "platform/blob/BlobRegistry.h"
@@ -104,8 +106,13 @@ void Blob::clampSliceOffsets(long long size, long long& start, long long& end)
         end = size;
 }
 
-PassRefPtrWillBeRawPtr<Blob> Blob::slice(long long start, long long end, const String& contentType) const
+PassRefPtrWillBeRawPtr<Blob> Blob::slice(long long start, long long end, const String& contentType, ExceptionState& exceptionState) const
 {
+    if (hasBeenClosed()) {
+        exceptionState.throwDOMException(InvalidStateError, "Blob has been closed.");
+        return nullptr;
+    }
+
     long long size = this->size();
     clampSliceOffsets(size, start, end);
 
@@ -116,23 +123,26 @@ PassRefPtrWillBeRawPtr<Blob> Blob::slice(long long start, long long end, const S
     return Blob::create(BlobDataHandle::create(blobData.release(), length));
 }
 
-void Blob::close(ExecutionContext* executionContext)
+void Blob::close(ExecutionContext* executionContext, ExceptionState& exceptionState)
 {
-    if (!hasBeenClosed()) {
-        // Dereferencing a Blob that has been closed should result in
-        // a network error. Revoke URLs registered against it through
-        // its UUID.
-        DOMURL::revokeObjectUUID(executionContext, uuid());
-
-        // A closed Blob should have size zero, which most consumers
-        // will treat as an empty Blob. The exception being the FileReader
-        // read operations which will throw.
-        // FIXME: spec not yet set in stone in this regard, track updates to it (http://crbug.com/344820.)
-        OwnPtr<BlobData> blobData = BlobData::create();
-        blobData->setContentType(type());
-        m_blobDataHandle = BlobDataHandle::create(blobData.release(), 0);
-        m_hasBeenClosed = true;
+    if (hasBeenClosed()) {
+        exceptionState.throwDOMException(InvalidStateError, "Blob has been closed.");
+        return;
     }
+
+    // Dereferencing a Blob that has been closed should result in
+    // a network error. Revoke URLs registered against it through
+    // its UUID.
+    DOMURL::revokeObjectUUID(executionContext, uuid());
+
+    // A Blob enters a 'readability state' of closed, where it will report its
+    // size as zero. Blob and FileReader operations now throws on
+    // being passed a Blob in that state. Downstream uses of closed Blobs
+    // (e.g., XHR.send()) consider them as empty.
+    OwnPtr<BlobData> blobData = BlobData::create();
+    blobData->setContentType(type());
+    m_blobDataHandle = BlobDataHandle::create(blobData.release(), 0);
+    m_hasBeenClosed = true;
 }
 
 void Blob::appendTo(BlobData& blobData) const

third_party/WebKit/Source/core/fileapi/Blob.h

@@ -42,6 +42,7 @@
 
 namespace WebCore {
 
+class ExceptionState;
 class ExecutionContext;
 
 class Blob : public RefCountedWillBeGarbageCollectedFinalized<Blob>, public ScriptWrappable, public URLRegistrable {
@@ -59,8 +60,23 @@ public:
     virtual ~Blob();
 
     virtual unsigned long long size() const { return m_blobDataHandle->size(); }
-    virtual PassRefPtrWillBeRawPtr<Blob> slice(long long start = 0, long long end = std::numeric_limits<long long>::max(), const String& contentType = String()) const;
-    virtual void close(ExecutionContext*);
+    virtual PassRefPtrWillBeRawPtr<Blob> slice(long long start, long long end, const String& contentType, ExceptionState&) const;
+
+    // To allow ExceptionState to be passed in last, manually enumerate the optional argument overloads.
+    PassRefPtrWillBeRawPtr<Blob> slice(ExceptionState& exceptionState) const
+    {
+        return slice(0, std::numeric_limits<long long>::max(), String(), exceptionState);
+    }
+    PassRefPtrWillBeRawPtr<Blob> slice(long long start, ExceptionState& exceptionState) const
+    {
+        return slice(start, std::numeric_limits<long long>::max(), String(), exceptionState);
+    }
+    PassRefPtrWillBeRawPtr<Blob> slice(long long start, long long end, ExceptionState& exceptionState) const
+    {
+        return slice(start, end, String(), exceptionState);
+    }
+
+    virtual void close(ExecutionContext*, ExceptionState&);
 
     String type() const { return m_blobDataHandle->type(); }
     String uuid() const { return m_blobDataHandle->uuid(); }

third_party/WebKit/Source/core/fileapi/Blob.idl

@@ -38,7 +38,7 @@
     readonly attribute unsigned long long size;
     readonly attribute DOMString type;
 
-    Blob slice(optional long long start, optional long long end, [TreatNullAs=NullString, TreatUndefinedAs=NullString] optional DOMString contentType);
-    [CallWith=ExecutionContext, RuntimeEnabled=FileAPIBlobClose] void close();
+    [RaisesException] Blob slice(optional long long start, optional long long end, [TreatNullAs=NullString, TreatUndefinedAs=NullString] optional DOMString contentType);
+    [RaisesException, CallWith=ExecutionContext, RuntimeEnabled=FileAPIBlobClose] void close();
 };
 

third_party/WebKit/Source/core/fileapi/File.cpp

@@ -26,6 +26,8 @@
 #include "config.h"
 #include "core/fileapi/File.h"
 
+#include "bindings/v8/ExceptionState.h"
+#include "core/dom/ExceptionCode.h"
 #include "platform/FileMetadata.h"
 #include "platform/MIMETypeRegistry.h"
 #include "public/platform/Platform.h"
@@ -181,10 +183,15 @@ unsigned long long File::size() const
     return static_cast<unsigned long long>(size);
 }
 
-PassRefPtrWillBeRawPtr<Blob> File::slice(long long start, long long end, const String& contentType) const
+PassRefPtrWillBeRawPtr<Blob> File::slice(long long start, long long end, const String& contentType, ExceptionState& exceptionState) const
 {
+    if (hasBeenClosed()) {
+        exceptionState.throwDOMException(InvalidStateError, "File has been closed.");
+        return nullptr;
+    }
+
     if (!m_hasBackingFile)
-        return Blob::slice(start, end, contentType);
+        return Blob::slice(start, end, contentType, exceptionState);
 
     // FIXME: This involves synchronous file operation. We need to figure out how to make it asynchronous.
     long long size;
@@ -225,19 +232,22 @@ void File::captureSnapshot(long long& snapshotSize, double& snapshotModification
     snapshotModificationTime = metadata.modificationTime;
 }
 
-void File::close(ExecutionContext* executionContext)
+void File::close(ExecutionContext* executionContext, ExceptionState& exceptionState)
 {
-    if (!hasBeenClosed()) {
-        // Reset the File to its closed representation, an empty
-        // Blob. The name isn't cleared, as it should still be
-        // available.
-        m_hasBackingFile = false;
-        m_path = String();
-        m_fileSystemURL = KURL();
-        invalidateSnapshotMetadata();
-        m_relativePath = String();
-        Blob::close(executionContext);
+    if (hasBeenClosed()) {
+        exceptionState.throwDOMException(InvalidStateError, "Blob has been closed.");
+        return;
     }
+
+    // Reset the File to its closed representation, an empty
+    // Blob. The name isn't cleared, as it should still be
+    // available.
+    m_hasBackingFile = false;
+    m_path = String();
+    m_fileSystemURL = KURL();
+    invalidateSnapshotMetadata();
+    m_relativePath = String();
+    Blob::close(executionContext, exceptionState);
 }
 
 void File::appendTo(BlobData& blobData) const

third_party/WebKit/Source/core/fileapi/File.h

@@ -33,6 +33,7 @@
 
 namespace WebCore {
 
+class ExceptionState;
 class ExecutionContext;
 struct FileMetadata;
 class KURL;
@@ -88,8 +89,8 @@ public:
     }
 
     virtual unsigned long long size() const OVERRIDE;
-    virtual PassRefPtrWillBeRawPtr<Blob> slice(long long start = 0, long long end = std::numeric_limits<long long>::max(), const String& contentType = String()) const OVERRIDE;
-    virtual void close(ExecutionContext*) OVERRIDE;
+    virtual PassRefPtrWillBeRawPtr<Blob> slice(long long start, long long end, const String& contentType, ExceptionState&) const OVERRIDE;
+    virtual void close(ExecutionContext*, ExceptionState&) OVERRIDE;
 
     virtual bool isFile() const OVERRIDE { return true; }
     virtual bool hasBackingFile() const OVERRIDE { return m_hasBackingFile; }

third_party/WebKit/Source/modules/filesystem/InspectorFileSystemAgent.cpp

@@ -471,7 +471,7 @@ bool FileContentRequest::didGetEntry(Entry* entry)
 
 bool FileContentRequest::didGetFile(File* file)
 {
-    RefPtrWillBeRawPtr<Blob> blob = file->slice(m_start, m_end);
+    RefPtrWillBeRawPtr<Blob> blob = static_cast<Blob*>(file)->slice(m_start, m_end, IGNORE_EXCEPTION);
     m_reader->setOnload(this);
     m_reader->setOnerror(this);