BlobBuilder/FormData refactor attempt

WebCore/platform/network/mac/FormDataStreamMac.mm

 /*
  * Copyright (C) 2005, 2006, 2008 Apple Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer. 
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 13 matching lines @@
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 /* originally written by Becky Willrich, additional code by Darin Adler */
 
 #import "config.h"
 #import "FormDataStreamMac.h"
 
-#import "Blob.h"
 #import "FileSystem.h"
 #import "FormData.h"
 #import "ResourceHandle.h"
 #import "ResourceHandleClient.h"
 #import "SchedulePair.h"
 #import "WebCoreSystemInterface.h"
 #import <sys/stat.h>
 #import <sys/types.h>
 #import <wtf/Assertions.h>
 #import <wtf/HashMap.h>
@@ skipping 90 matching lines @@
 };
 
 static void closeCurrentStream(FormStreamFields *form)
 {
     if (form->currentStream) {
         CFReadStreamClose(form->currentStream);
         CFReadStreamSetClient(form->currentStream, kCFStreamEventNone, NULL, NULL);
         CFRelease(form->currentStream);
         form->currentStream = NULL;
 #if ENABLE(BLOB_SLICE)
-        form->currentStreamRangeLength = Blob::toEndOfFile;
+        form->currentStreamRangeLength = FormDataElement::toEndOfFile;
 #endif
     }
     if (form->currentData) {
         fastFree(form->currentData);
         form->currentData = 0;
     }
 }
 
-// Return false if we cannot advance the stream. Currently the only possible failure is that the underlying file has been changed since File.slice. 
+// Return false if we cannot advance the stream. Currently the only possible failure is that the underlying file has been removed or changed since File.slice.
 static bool advanceCurrentStream(FormStreamFields* form)
 {
     closeCurrentStream(form);
 
     if (form->remainingElements.isEmpty())
         return true;
 
     // Create the new stream.
     FormDataElement& nextInput = form->remainingElements.last();
+
     if (nextInput.m_type == FormDataElement::data) {
         size_t size = nextInput.m_data.size();
         char* data = nextInput.m_data.releaseBuffer();
         form->currentStream = CFReadStreamCreateWithBytesNoCopy(0, reinterpret_cast<const UInt8*>(data), size, kCFAllocatorNull);
         form->currentData = data;
     } else {
 #if ENABLE(BLOB_SLICE)
         // Check if the file has been changed or not if required.
-        if (nextInput.m_expectedFileModificationTime != Blob::doNotCheckFileChange) {
+        if (nextInput.m_expectedFileModificationTime != FormDataElement::doNotCheckFileChange) {
             time_t fileModificationTime;
             if (!getFileModificationTime(nextInput.m_filename, fileModificationTime) || fileModificationTime != static_cast<time_t>(nextInput.m_expectedFileModificationTime))
                 return false;
         }
 #endif
-
         const String& path = nextInput.m_shouldGenerateFile ? nextInput.m_generatedFilename : nextInput.m_filename;
         RetainPtr<CFStringRef> filename(AdoptCF, path.createCFString());
         RetainPtr<CFURLRef> fileURL(AdoptCF, CFURLCreateWithFileSystemPath(0, filename.get(), kCFURLPOSIXPathStyle, FALSE));
         form->currentStream = CFReadStreamCreateWithFile(0, fileURL.get());
+        if (!form->currentStream) {
+            // The file must have been removed or become unreadable.
+            return false;
+        }
 #if ENABLE(BLOB_SLICE)
         if (nextInput.m_fileStart > 0) {
             CFNumberRef position = CFNumberCreate(0, kCFNumberLongLongType, &nextInput.m_fileStart);
             CFReadStreamSetProperty(form->currentStream, kCFStreamPropertyFileCurrentOffset, position);
         }
         form->currentStreamRangeLength = nextInput.m_fileLength;
 #endif
     }
     form->remainingElements.removeLast();
 
@@ skipping 22 matching lines @@
     return true;
 }
 
 static void* formCreate(CFReadStreamRef stream, void* context)
 {
     FormContext* formContext = static_cast<FormContext*>(context);
 
     FormStreamFields* newInfo = new FormStreamFields;
     newInfo->currentStream = NULL;
 #if ENABLE(BLOB_SLICE)
-    newInfo->currentStreamRangeLength = Blob::toEndOfFile;
+    newInfo->currentStreamRangeLength = FormDataElement::toEndOfFile;
 #endif
     newInfo->currentData = 0;
     newInfo->formStream = stream; // Don't retain. That would create a reference cycle.
     newInfo->streamLength = formContext->streamLength;
     newInfo->bytesSent = 0;
 
     FormData* formData = formContext->formData;
 
     // Append in reverse order since we remove elements from the end.
     size_t size = formData->elements().size();
@@ skipping 27 matching lines @@
     return opened;
 }
 
 static CFIndex formRead(CFReadStreamRef stream, UInt8* buffer, CFIndex bufferLength, CFStreamError* error, Boolean* atEOF, void* context)
 {
     FormStreamFields* form = static_cast<FormStreamFields*>(context);
 
     while (form->currentStream) {
         CFIndex bytesToRead = bufferLength;
 #if ENABLE(BLOB_SLICE)
-        if (form->currentStreamRangeLength != Blob::toEndOfFile && form->currentStreamRangeLength < bytesToRead)
+        if (form->currentStreamRangeLength != FormDataElement::toEndOfFile && form->currentStreamRangeLength < bytesToRead)
             bytesToRead = static_cast<CFIndex>(form->currentStreamRangeLength);
 #endif
         CFIndex bytesRead = CFReadStreamRead(form->currentStream, buffer, bytesToRead);
         if (bytesRead < 0) {
             *error = CFReadStreamGetError(form->currentStream);
             return -1;
         }
         if (bytesRead > 0) {
             error->error = 0;
             *atEOF = FALSE;
             form->bytesSent += bytesRead;
 #if ENABLE(BLOB_SLICE)
-            if (form->currentStreamRangeLength != Blob::toEndOfFile)
+            if (form->currentStreamRangeLength != FormDataElement::toEndOfFile)
                 form->currentStreamRangeLength -= bytesRead;
 #endif
 
             if (!ResourceHandle::didSendBodyDataDelegateExists()) {
                 // FIXME: Figure out how to only do this when a ResourceHandleClient is available.
                 DidSendDataCallbackData* data = new DidSendDataCallbackData(stream, form->bytesSent, form->streamLength);
                 callOnMainThread(performDidSendDataCallback, data);
             }
 
             return bytesRead;
@@ skipping 96 matching lines @@
 
     // Precompute the content length so NSURLConnection doesn't use chunked mode.
     long long length = 0;
     for (size_t i = 0; i < count; ++i) {
         const FormDataElement& element = formData->elements()[i];
         if (element.m_type == FormDataElement::data)
             length += element.m_data.size();
         else {
 #if ENABLE(BLOB_SLICE)
             // If we're sending the file range, use the existing range length for now. We will detect if the file has been changed right before we read the file and abort the operation if necessary.
-            if (element.m_fileLength != Blob::toEndOfFile) {
+            if (element.m_fileLength != FormDataElement::toEndOfFile) {
                 length += element.m_fileLength;
                 continue;
             }
 #endif
             long long fileSize;
             if (getFileSize(element.m_shouldGenerateFile ? element.m_generatedFilename : element.m_filename, fileSize))
                 length += fileSize;
         }
     }
 
@@ skipping 10 matching lines @@
         &formContext));
     [request setHTTPBodyStream:(NSInputStream *)stream.get()];
 }
 
 FormData* httpBodyFromStream(NSInputStream* stream)
 {
     return getStreamFormDataMap().get((CFReadStreamRef)stream).get();
 }
 
 } // namespace WebCore