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

chrome/browser/extensions/api/downloads/downloads_api_unittest.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 <algorithm>
 
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_reader.h"
 #include "base/message_loop.h"
@@ skipping 28 matching lines @@
 #include "content/public/test/download_test_observer.h"
 #include "content/test/net/url_request_slow_download_job.h"
 #include "net/base/data_url.h"
 #include "net/base/net_util.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_job.h"
 #include "net/url_request/url_request_job_factory.h"
 #include "net/url_request/url_request_job_factory_impl.h"
 #include "webkit/blob/blob_data.h"
-#include "webkit/blob/blob_storage_controller.h"
+#include "webkit/blob/blob_storage_context.h"
 #include "webkit/blob/blob_url_request_job.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_operation.h"
 #include "webkit/fileapi/file_system_url.h"
 
 using content::BrowserContext;
 using content::BrowserThread;
 using content::DownloadItem;
 using content::DownloadManager;
 using content::URLRequestSlowDownloadJob;
@@ skipping 555 matching lines @@
           (*item), base::Bind(&ItemNotInProgress));
       observer.WaitForEvent();
     }
   }
 
  private:
   DownloadManager::DownloadVector* items_;
   DISALLOW_COPY_AND_ASSIGN(ScopedItemVectorCanceller);
 };
 
+#if 0
 class TestProtocolHandler : public net::URLRequestJobFactory::ProtocolHandler {
  public:
   explicit TestProtocolHandler(
-      webkit_blob::BlobStorageController* blob_storage_controller,
+      webkit_blob::BlobStorageContext* blob_storage_context,
       fileapi::FileSystemContext* file_system_context)
-      : blob_storage_controller_(blob_storage_controller),
+      : blob_storage_context_(blob_storage_context),
         file_system_context_(file_system_context) {}
 
   virtual ~TestProtocolHandler() {}
 
   virtual net::URLRequestJob* MaybeCreateJob(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const OVERRIDE {
     return new webkit_blob::BlobURLRequestJob(
         request,
         network_delegate,
-        blob_storage_controller_->GetBlobDataFromUrl(request->url()),
+        blob_storage_context_->GetBlobDataFromUrl(request->url()),
         file_system_context_,
         base::MessageLoopProxy::current());
   }
 
  private:
-  webkit_blob::BlobStorageController* const blob_storage_controller_;
+  webkit_blob::BlobStorageContext* const blob_storage_context_;
   fileapi::FileSystemContext* const file_system_context_;
 
   DISALLOW_COPY_AND_ASSIGN(TestProtocolHandler);
 };
 
 class TestURLRequestContext : public net::URLRequestContext {
  public:
   explicit TestURLRequestContext(
       fileapi::FileSystemContext* file_system_context)
-      : blob_storage_controller_(new webkit_blob::BlobStorageController) {
+      : blob_storage_context_(new webkit_blob::BlobStorageContext) {
     // Job factory owns the protocol handler.
     job_factory_.SetProtocolHandler(
-        "blob", new TestProtocolHandler(blob_storage_controller_.get(),
+        "blob", new TestProtocolHandler(blob_storage_context_.get(),
                                         file_system_context));
     set_job_factory(&job_factory_);
   }
 
   virtual ~TestURLRequestContext() {}
 
-  webkit_blob::BlobStorageController* blob_storage_controller() const {
-    return blob_storage_controller_.get();
+  webkit_blob::BlobStorageContext* blob_storage_context() const {
+    return blob_storage_context_.get();
   }
 
  private:
   net::URLRequestJobFactoryImpl job_factory_;
-  scoped_ptr<webkit_blob::BlobStorageController> blob_storage_controller_;
+  scoped_ptr<webkit_blob::BlobStorageContext> blob_storage_context_;
 
   DISALLOW_COPY_AND_ASSIGN(TestURLRequestContext);
 };
 
 // TODO(benjhayden): Comment.
+//
+// TODO(michaeln): Wow, lots of complexity to create a filesystem file as a
+// precondition for the DownloadExtensionTest_Download_FileSystemURL.
+// Some alternatives come to mind:
+// - load an html page that will produce the file
+// - more directly write and  create the file using lower level
+//   fileapi::FileSystemFileUtilProxy to create the dir entry
+//   and  write directly into the platform file path using  base file_utils.
 class HTML5FileWriter {
  public:
   HTML5FileWriter(
       Profile* profile,
       const std::string& filename,
       const std::string& origin,
       DownloadsEventsListener* events_listener,
       const std::string& payload)
     : profile_(profile),
       filename_(filename),
       origin_(origin),
       events_listener_(events_listener),
       blob_data_(new webkit_blob::BlobData()),
       payload_(payload),
       fs_(BrowserContext::GetDefaultStoragePartition(profile_)->
           GetFileSystemContext()) {
     CHECK(profile_);
     CHECK(events_listener_);
     CHECK(fs_);
   }
 
   ~HTML5FileWriter() {
     CHECK(BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
         &HTML5FileWriter::TearDownURLRequestContext, base::Unretained(this))));
     events_listener_->WaitFor(profile_, kURLRequestContextToreDown, "");
   }
 
   bool WriteFile() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    // TODO(michaeln): FSContext should not be used on the UI thread,
+    // this part of the sequence should also be invoked on the IO thread.
     fs_->OpenFileSystem(
         GURL(origin_),
         fileapi::kFileSystemTypeTemporary,
         kCreateFileSystem,
         base::Bind(&HTML5FileWriter::OpenFileSystemCallback,
                    base::Unretained(this)));
     return events_listener_->WaitFor(profile_, kHTML5FileWritten, filename_);
   }
 
  private:
@@ skipping 23 matching lines @@
     operation()->CreateFile(fs_->CrackURL(GURL(root_ + filename_)),
         kExclusive, base::Bind(
             &HTML5FileWriter::CreateFileCallback, base::Unretained(this)));
   }
 
   void CreateFileCallback(base::PlatformFileError result) {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     CHECK_EQ(base::PLATFORM_FILE_OK, result);
     blob_data_->AppendData(payload_);
     url_request_context_.reset(new TestURLRequestContext(fs_));
-    url_request_context_->blob_storage_controller()->AddFinishedBlob(
+    url_request_context_->blob_storage_context()->AddFinishedBlob(
         blob_url(), blob_data_);
     operation()->Write(
         url_request_context_.get(),
         fs_->CrackURL(GURL(root_ + filename_)),
         blob_url(),
         0,  // offset
         base::Bind(&HTML5FileWriter::WriteCallback, base::Unretained(this)));
   }
 
   void WriteCallback(
@@ skipping 13 matching lines @@
     notification_source.profile = profile_;
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_EXTENSION_DOWNLOADS_EVENT,
         content::Source<DownloadsEventsListener::DownloadsNotificationSource>(
           &notification_source),
         content::Details<std::string>(&filename_));
   }
 
   void TearDownURLRequestContext() {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-    url_request_context_->blob_storage_controller()->RemoveBlob(blob_url());
+    url_request_context_->blob_storage_context()->RemoveBlob(blob_url());
     url_request_context_.reset();
     CHECK(BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
         &HTML5FileWriter::NotifyURLRequestContextToreDown,
         base::Unretained(this))));
   }
 
   void NotifyURLRequestContextToreDown() {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     DownloadsEventsListener::DownloadsNotificationSource notification_source;
     notification_source.event_name = kURLRequestContextToreDown;
@@ skipping 15 matching lines @@
   std::string payload_;
   scoped_ptr<TestURLRequestContext> url_request_context_;
   fileapi::FileSystemContext* fs_;
 
   DISALLOW_COPY_AND_ASSIGN(HTML5FileWriter);
 };
 
 const char HTML5FileWriter::kHTML5FileWritten[] = "html5_file_written";
 const char HTML5FileWriter::kURLRequestContextToreDown[] =
   "url_request_context_tore_down";
+#endif
 
 }  // namespace
 
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
                        DownloadExtensionTest_Open) {
   EXPECT_STREQ(download_extension_errors::kInvalidOperationError,
                RunFunctionAndReturnError(
                    new DownloadsOpenFunction(),
                    "[-42]").c_str());
 
@@ skipping 1256 matching lines @@
   item->Cancel(true);
   ASSERT_TRUE(WaitFor(events::kOnDownloadChanged,
       base::StringPrintf("[{\"id\": %d,"
                           "  \"error\": {\"current\": 40},"
                           "  \"state\": {"
                           "    \"previous\": \"in_progress\","
                           "    \"current\": \"interrupted\"}}]",
                           result_id)));
 }
 
+#if 0
 // Test downloading filesystem: URLs.
 // NOTE: chrome disallows creating HTML5 FileSystem Files in incognito.
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
                        DownloadExtensionTest_Download_FileSystemURL) {
   static const char* kPayloadData = "on the record\ndata";
   GoOnTheRecord();
   LoadExtension("downloads_split");
   HTML5FileWriter html5_file_writer(
       browser()->profile(),
       "on_record.txt",
@@ skipping 31 matching lines @@
                           "  \"state\": {"
                           "    \"previous\": \"in_progress\","
                           "    \"current\": \"complete\"}}]",
                           result_id,
                           GetFilename("on_record.txt.crdownload").c_str(),
                           GetFilename("on_record.txt").c_str())));
   std::string disk_data;
   EXPECT_TRUE(file_util::ReadFileToString(item->GetFullPath(), &disk_data));
   EXPECT_STREQ(kPayloadData, disk_data.c_str());
 }
+#endif