********** Content tests with blob hacking.

webkit/tools/test_shell/simple_file_writer.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/tools/test_shell/simple_file_writer.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
 #include "net/url_request/url_request_context.h"
+#include "webkit/blob/blob_storage_context.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_operation.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_url.h"
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/tools/test_shell/simple_resource_loader_bridge.h"
 
 using fileapi::FileSystemURL;
 using fileapi::FileSystemContext;
 using fileapi::FileSystemOperation;
 using fileapi::WebFileWriterBase;
 using WebKit::WebFileWriterClient;
 using WebKit::WebString;
 using WebKit::WebURL;
 
-net::URLRequestContext* SimpleFileWriter::request_context_ = NULL;
+net::URLRequestContext* SimpleFileWriter::request_context_;
+webkit_blob::BlobStorageContext* SimpleFileWriter::blob_storage_context_;
 
 // Helper class to proxy to write and truncate calls to the IO thread,
 // and to proxy the results back to the main thead. There is a one-to-one
 // relationship between SimpleFileWriters and IOThreadBackends.
 class SimpleFileWriter::IOThreadProxy
     : public base::RefCountedThreadSafe<SimpleFileWriter::IOThreadProxy> {
  public:
   IOThreadProxy(const base::WeakPtr<SimpleFileWriter>& simple_writer,
                 FileSystemContext* file_system_context)
       : simple_writer_(simple_writer),
@@ skipping 13 matching lines @@
       return;
     }
     if (FailIfNotWritable(url))
       return;
     DCHECK(!operation_);
     operation_ = GetNewOperation(url);
     operation_->Truncate(url, offset,
                          base::Bind(&IOThreadProxy::DidFinish, this));
   }
 
-  void Write(const FileSystemURL& url, const GURL& blob_url, int64 offset) {
+  void Write(const FileSystemURL& url,
+             const std::string& blob_uuid,
+             int64 offset) {
     if (!io_thread_->BelongsToCurrentThread()) {
       io_thread_->PostTask(
           FROM_HERE,
-          base::Bind(&IOThreadProxy::Write, this, url, blob_url, offset));
+          base::Bind(&IOThreadProxy::Write, this, url, blob_uuid, offset));
       return;
     }
     if (FailIfNotWritable(url))
       return;
     DCHECK(request_context_);
     DCHECK(!operation_);
     operation_ = GetNewOperation(url);
-    operation_->Write(request_context_, url, blob_url, offset,
+    scoped_ptr<webkit_blob::BlobDataHandle> blob_data_handle =
+        blob_storage_context_->GetBlobDataFromUUID(blob_uuid);
+    operation_->Write(request_context_, url, blob_data_handle.Pass(), offset,
                       base::Bind(&IOThreadProxy::DidWrite, this));
   }
 
   void Cancel() {
     if (!io_thread_->BelongsToCurrentThread()) {
       io_thread_->PostTask(
           FROM_HERE,
           base::Bind(&IOThreadProxy::Cancel, this));
       return;
     }
@@ skipping 104 matching lines @@
 
 SimpleFileWriter::~SimpleFileWriter() {
 }
 
 void SimpleFileWriter::DoTruncate(const GURL& path, int64 offset) {
   FileSystemURL url = file_system_context_->CrackURL(path);
   io_thread_proxy_->Truncate(url, offset);
 }
 
 void SimpleFileWriter::DoWrite(
-    const GURL& path, const GURL& blob_url, int64 offset) {
+    const GURL& path,  const std::string& blob_uuid, int64 offset) {
   FileSystemURL url = file_system_context_->CrackURL(path);
-  io_thread_proxy_->Write(url, blob_url, offset);
+  io_thread_proxy_->Write(url, blob_uuid, offset);
 }
 
 void SimpleFileWriter::DoCancel() {
   io_thread_proxy_->Cancel();
 }