********** Chromium Blob hacking

webkit/fileapi/local_file_system_operation.cc

 // Copyright (c) 2012 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 "webkit/fileapi/local_file_system_operation.h"
 
 #include "base/bind.h"
 #include "base/single_thread_task_runner.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/escape.h"
 #include "net/url_request/url_request_context.h"
+#include "webkit/blob/blob_storage_context.h"
 #include "webkit/blob/shareable_file_reference.h"
+#include "webkit/blob/blob_url_request_job_factory.h"
 #include "webkit/fileapi/async_file_util.h"
 #include "webkit/fileapi/cross_operation_delegate.h"
 #include "webkit/fileapi/file_observers.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_mount_point_provider.h"
 #include "webkit/fileapi/file_system_task_runners.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_url.h"
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/fileapi/file_writer_delegate.h"
@@ skipping 217 matching lines @@
                      base::Unretained(this), callback)));
   if (recursive)
     recursive_operation_delegate_->RunRecursively();
   else
     recursive_operation_delegate_->Run();
 }
 
 void LocalFileSystemOperation::Write(
     const net::URLRequestContext* url_request_context,
     const FileSystemURL& url,
-    const GURL& blob_url,
+    scoped_ptr<webkit_blob::BlobDataHandle> blob,
     int64 offset,
     const WriteCallback& callback) {
-  GetWriteClosure(url_request_context, url, blob_url, offset, callback).Run();
+  GetWriteClosure(url_request_context, url, blob.Pass(), offset, callback)
+      .Run();
 }
 
 void LocalFileSystemOperation::Truncate(const FileSystemURL& url, int64 length,
                                         const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationTruncate));
 
   base::PlatformFileError result = SetUp(url, SETUP_FOR_WRITE);
   if (result != base::PLATFORM_FILE_OK) {
     callback.Run(result);
     delete this;
@@ skipping 312 matching lines @@
     return;
   }
 
   operation_context()->set_allowed_bytes_growth(quota - usage);
   task.Run();
 }
 
 base::Closure LocalFileSystemOperation::GetWriteClosure(
     const net::URLRequestContext* url_request_context,
     const FileSystemURL& url,
-    const GURL& blob_url,
+    scoped_ptr<webkit_blob::BlobDataHandle> blob_handle,
     int64 offset,
     const WriteCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationWrite));
 
   base::PlatformFileError result = SetUp(url, SETUP_FOR_WRITE);
   if (result != base::PLATFORM_FILE_OK) {
     return base::Bind(&LocalFileSystemOperation::DidFailWrite,
                       base::Owned(this), callback, result);
   }
 
   FileSystemMountPointProvider* provider = file_system_context()->
       GetMountPointProvider(url.type());
   DCHECK(provider);
   scoped_ptr<FileStreamWriter> writer(provider->CreateFileStreamWriter(
           url, offset, file_system_context()));
 
   if (!writer.get()) {
     // Write is not supported.
     return base::Bind(&LocalFileSystemOperation::DidFailWrite,
                       base::Owned(this), callback,
                       base::PLATFORM_FILE_ERROR_SECURITY);
   }
 
-  DCHECK(blob_url.is_valid());
   file_writer_delegate_.reset(new FileWriterDelegate(
       base::Bind(&LocalFileSystemOperation::DidWrite,
                  weak_factory_.GetWeakPtr(), url),
       writer.Pass()));
 
   write_callback_ = callback;
+
+  // Use a URLRequest to read the blob data that's to be written to the file.
   scoped_ptr<net::URLRequest> blob_request(url_request_context->CreateRequest(
-      blob_url, file_writer_delegate_.get()));
+      GURL("blob://see_user_data/"), file_writer_delegate_.get()));
+  webkit_blob::BlobProtocolHandler::SetRequestedBlobDataHandle(
+      blob_request.get(),
+      blob_handle.Pass());
 
   return base::Bind(&FileWriterDelegate::Start,
                     base::Unretained(file_writer_delegate_.get()),
                     base::Passed(&blob_request));
 }
 
 void LocalFileSystemOperation::DidFailWrite(
     const WriteCallback& callback,
     base::PlatformFileError result) {
   callback.Run(result, 0, false);
@@ skipping 231 matching lines @@
 }
 
 bool LocalFileSystemOperation::SetPendingOperationType(OperationType type) {
   if (pending_operation_ != kOperationNone)
     return false;
   pending_operation_ = type;
   return true;
 }
 
 }  // namespace fileapi