Status: Untriaged
Owner: ----
CC: dgr...@chromium.org,  jsb...@chromium.org
Labels: Type-Bug Pri-2 Area-WebKit ImportantForOffline Feature-IndexedDB

New issue 108012 by ericbide...@chromium.org: IndexedDB should support  
storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

FF has this implemented:
https://bugzilla.mozilla.org/show_bug.cgi?id=661877

I'm currently seeing Mac, 18.0.974.0 canary crash when trying to .put() a  
File.

Comment #2 on issue 108012 by jsb...@chromium.org: IndexedDB should support  

storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

File via the FileSystem API appears to be working correctly, except that  
the name property becomes all zeros (!).

ericbidelman@ - I don't suppose you have a repro handy?

Comment #3 on issue 108012 by ericbide...@chromium.org: IndexedDB should  

support storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

Sure. Attached has code that's compatible with FF (though not currently  
working in their nightlies),
but repos fine in WebKit. It crashes Chrome for me.

Again: Mac OSX, 10.6.8 17.0.963.12 dev

Attachments:
        indexeddb_save_file.html  5.6 KB

Comment #5 on issue 108012 by jsb...@chromium.org: IndexedDB should support  

storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

The important bit in the repro is that the object store has a keyPath and  
that the data being put contains a File. This triggers the crash regardless  
of whether autoIncrement is set or whether the path resolves to anything in  
the data being put.

Comment #11 on issue 108012 by jsb...@chromium.org: IndexedDB should  

support storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

With this patch in place:

diff --git a/Source/WebCore/bindings/v8/V8DOMWrapper.cpp  
b/Source/WebCore/bindings/v8/V8DOMWrapper.cpp
index 0b757ca..2e68bab 100644
--- a/Source/WebCore/bindings/v8/V8DOMWrapper.cpp
+++ b/Source/WebCore/bindings/v8/V8DOMWrapper.cpp
@@ -222,8 +222,9 @@ v8::Local<v8::Object>  
V8DOMWrapper::instantiateV8Object(V8Proxy* proxy, WrapperT
                      proxy = V8Proxy::retrieve(frame);
              }
  #if ENABLE(WORKERS)
-            else
+            else if (isWrapperOfType(globalPrototype,  
&V8WorkerContext::info)) {
                  workerContext =  
V8WorkerContext::toNative(lookupDOMWrapper(V8WorkerContext::GetTemplate(),  
context->Global()));
+            }
  #endif
          }

... Chromium fails a DCHECK in webkit/blob/blob_storage_controller.cc:137,  
in BlobStorageController::CloneBlob:

BlobData* blob_data = GetBlobDataFromUrl(src_url);
DCHECK(blob_data);

[27193:27209:76966562271:FATAL:blob_storage_controller.cc(137)] Check  
failed: blob_data.
Backtrace:
        base::debug::StackTrace::StackTrace() [0x7f9c6be87f7e]
        logging::LogMessage::~LogMessage() [0x7f9c6beb2f20]
        webkit_blob::BlobStorageController::CloneBlob() [0x7f9c6dc93f09]
        BlobMessageFilter::OnCloneBlob() [0x7f9c6c956d80]
        DispatchToMethod<>() [0x7f9c6c957a6b]
        BlobHostMsg_CloneBlob::Dispatch<>() [0x7f9c6c9575d9]
        BlobMessageFilter::OnMessageReceived() [0x7f9c6c9566ea]
        content::BrowserMessageFilter::DispatchMessage() [0x7f9c6c701d17]
        content::BrowserMessageFilter::OnMessageReceived() [0x7f9c6c701bb4]
        IPC::ChannelProxy::Context::TryFilters() [0x7f9c6bb8f8ff]
        IPC::ChannelProxy::Context::OnMessageReceived() [0x7f9c6bb8f983]
        IPC::Channel::ChannelImpl::ProcessIncomingMessages() [0x7f9c6bb8a2bd]
        IPC::Channel::ChannelImpl::OnFileCanReadWithoutBlocking() [0x7f9c6bb8c185]
        
base::MessagePumpLibevent::FileDescriptorWatcher::OnFileCanReadWithoutBlocking()  
[0x7f9c6be74268]
        base::MessagePumpLibevent::OnLibeventNotification() [0x7f9c6be7623b]
        event_process_active [0x7f9c6e4e1779]
        event_base_loop [0x7f9c6e4e1aa8]
        base::MessagePumpLibevent::Run() [0x7f9c6be75a19]
        MessageLoop::RunInternal() [0x7f9c6beb7ba3]
        MessageLoop::RunHandler() [0x7f9c6beb7a56]
        MessageLoop::Run() [0x7f9c6beb738b]
        base::Thread::Run() [0x7f9c6bf0424e]
        base::Thread::ThreadMain() [0x7f9c6bf043ce]
        base::(anonymous namespace)::ThreadFunc() [0x7f9c6befa9cf]
        start_thread [0x7f9c6578d9ca]
        0x7f9c6296670d

Trace/breakpoint trap

Updates:
        Cc: er...@chromium.org

Comment #20 on issue 108012 by jsb...@chromium.org: IndexedDB should  

support storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

(No comment was entered for this change.)

Updates:
        Owner: er...@chromium.org

Comment #22 on issue 108012 by jsb...@chromium.org: IndexedDB should  

Updates:
        Cc: jia...@chromium.org

Comment #23 on issue 108012 by dim...@chromium.org: IndexedDB should  

support storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

We hit this trying to build an offline app. We pull avatar images using XHR  
(as blobs) then mint URLs for those blobs and set it to img.src. To have an  
offline app, we want to store those in IDB.

Eric, what's your prognosis?

Comment #28 on issue 108012 by alecfl...@chromium.org: IndexedDB should  

support storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

Unfortunately, we are not actively working on a fix for this right now - we  
do want to add blob support, but we don't have the resources to work on  
this at least for a month or so. We will do our best to update this bug as  
this changes.

Comment #30 on issue 108012 by piranna: IndexedDB should support storing  
File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

There's any progress with this issue? At least on any nightly or personal  
branch that i would be able to download and compile (i'm using Ubuntu, if  
that's matters)?

Comment #32 on issue 108012 by ygutfre...@gmail.com: IndexedDB should  

support storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

Now let’s see if I cannot motivate you why this would be a great addition.

I workin in a R&D firm on BigData. CouchDB and other NoSQL are ideal for  
storing the loosely structured mix of imagery, video, meta-info , signals  
data, etc.  Mobile users (laptops, tablets, phones) need to grab snippets  
of this and work offline for periods, and then re-connect. I need something  
for NoSQL on the client side.

Think of massive multiplayer outdoor collaboration gaming, where the game  
database is stored on the cloud and people are constantly connecting and  
disconnecting.  The CouchDB central store is where all the loosely  
collected imagery, audio, and derived meta-information  (JSON objects )is  
collected and processed.

So when you do add it, can you make sure it also works for Chrome for  
Android?

Comment #33 on issue 108012 by jsb...@chromium.org: IndexedDB should  

support storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

We don't need any motivation, Blob support has just been below other work  
in the priority queue. It's bubbling it's way slowly to the top, closer all  
the time. Supporting it on Android is important too. Hopefully we'll have  
news soon.

Comment #34 on issue 108012 by piranna: IndexedDB should support storing  
File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

Could you be able to give a (orientative) release? v26? Maybe v27? After  
v27?

Comment #35 on issue 108012 by ygutfre...@gmail.com: IndexedDB should  

support storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

Good to know you are motivated, I have the flexibility to wait. But I do  
see comments here about serializing/deserializing the blob. I don't know if  
FireFox is doing that, but if at all possible, I would rather see native  
binary storage if possible. I am talking about blobs in the 10KB size  
range, but I would have several hundred, and I need very fast retrieval.  
Otherwise, I will do a polyfill that uses FileSystemAPI. (Perhaps you can  
do the same, and store blobs in a hidden directory there?)

Comment #36 on issue 108012 by ygutfre...@gmail.com: IndexedDB should  

support storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

In case I was not clear, I meant store a reference in the IDB entry, with  
metadata and a pointer to the FileSystem binary blob. (Just one possible  
way to do this).

Comment #37 on issue 108012 by piranna: IndexedDB should support storing  
File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

I would be very interested in your polyfill, since I need to work with  
several megabytes files with access and modification of chunks and using  
the FileSystem API to fix IndexedDB would be great. Currently I'm using an  
on-memory IndexedDB implementation and modifying full blobs just to  
circunvent temporaly this issue and don't have the files stored it's fairly  
user unfriendly... I didn't be able to figure out how to create a polyfill  
to add support for File and Blob objects using FileSystem API (I thought  
about it some months ago), but if you have some idea and needs help or  
testing don't doubt in call me :-)

By the way, here is my project: http:// github.com/piranna/ShareIt (I'm  
using IndexedDB for cache since it's available both for Firefox and Chrome,  
but first versions were using FileSystem API).

Comment #38 on issue 108012 by ericbide...@google.com: IndexedDB should  

support storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

I made the opposite polyfill, idb.filesystem.js  
(http://ericbidelman.tumblr.com/post/21649963613/idb-filesystem-js-bringing-the-html5-filesystem-api)  
as a polyfill for the FS API. It uses IDB under the hood for FF and other  
implementations that support saving Blobs to IDB. You could try

Comment #39 on issue 108012 by piranna: IndexedDB should support storing  
File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

I did, indeed :-D Also I improved your FileWriter class adding seek() and  
random write() according to specification that I have been using sucesfully  
the last months. You have a pull-request with the changes on GitHub :-)

Comment #40 on issue 108012 by ericbide...@chromium.org: IndexedDB should  

support storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

I must have missed that. I'll take a look. Thanks!

Comment #44 on issue 108012 by cos...@gmail.com: IndexedDB should support  

storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

@piranna: Blob support is sufficient for caching data. If you have a file,  
you can read it into an ArrayBuffer and make a Blob out of that, then store  
the Blob :D

Also, I was a bit wrong above. Building a Blob out of a binary string  
requires going through an Uint8Array. (set byte i to string.charCodeAt(i) &  
0xff, for i in 0...string.length)

Comment #45 on issue 108012 by piranna: IndexedDB should support storing  
File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

I'm using it just this way to cache downloading content... :-D



copy... :-/

Comment #46 on issue 108012 by ygutfre...@gmail.com: IndexedDB should  

support storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

For my app, "Building a Blob out of a binary string requires going through  
an Uint8Array" seems a bit slow and kludgy. What about the idea of writing  
the blob to unique place in the FileSystem (/blobstore/key ), and then  
storing the reference in the objectStore in the format {blob-key: xxx,  
path: xxxx }

Comment #47 on issue 108012 by piranna: IndexedDB should support storing  
File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

I found this way better... In fact Firefox do it this way, Blob and
Javascript-generated File objects inserted on IndexedDB are stored directly
on the underlying computer filesystem (or at least I read that...).

How could be done a polyfill for this? Override the ObjectStore methods and
inspect each object attribute to detect when one of them is a Blob object?

Comment #48 on issue 108012 by benjamin...@gmail.com: IndexedDB should  

support storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

Yes that`s right in Firefox blobs are stored in the filesystem and you can  
even go there and open them.
So i was able to download a movie to the IndexedDB as a blob and then in  
the filesystem open it with VLC.
BTW the same thing works in IE10.

Comment #49 on issue 108012 by piranna: IndexedDB should support storing  
File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

So it would be great to do a polyfill for this... At least I would have
persistence and don't need to use my in-memory implementation... :-P

Sent from my Android cell phone, please forgive the lack of format on the
text, and my fat thumbs :-P
El 11/01/2013 08:46, <chro...@googlecode.com> escribi�:

Comment #50 on issue 108012 by ygutfre...@gmail.com: IndexedDB should  
support storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

This is just a FYI. Perhaps it will help in your design.

I did a polyfill to store the results in the FileSystem. See below for the  
full results. But to summarize. It works. But performance is best in IE,  
which stores the results in the DB. FireFox is very poor. BTW, when I  
increase the number of files to 6,760 (220MB). I start getting all sorts of  
xhr error code: 0 errors, and it does not fetch all the PNG files (even  
though they are there). IE10 works fine with 220MB of files, and finishes  
in 15s! Superb.

Results Offline blob cache for PNG slippy maps

Testing

     171 PNG files (total of 3.2MB)
     Platforms tested: Chrome v24, FireFox 18, IE 10
     Should also work with Chrome & FF for Android

Fetch from web server

     using XHR2 (supported on almost all browsers) for blob download from  
web server
     I went with XHR2-Lib by Phil Parsons, which is very much like  
JQUERY .ajax()
         https://github.com/p-m-p/xhr2-lib

Storage

     IndexedDB for IE and FireFox
     Chrome: Polyfill (blob stored using FileSystem API, reference kept in  
IndexedDB) polyfill
     A Must read article on "How the browsers store IndexedDB data"
         http://www.aaron-powell.com/web/indexeddb-storage
     Note: FireFox uses SQLlite for the NOSQL IndexedDB. That might be the  
reason for the slow performance. (blobs stored separately)
     Note: Microsoft IE uses the extensible storage engine:
         http://en.wikipedia.org/wiki/Extensible_Storage_Engine
     Note: Chrome uses LevelDB http://code.google.com/p/leveldb/

Display

     I am using Leaflet http://leafletjs.com/ to show the map tiles
     I used the functional tile layer plugin by Ishmael Smyrnow for fetching  
the tile layer from the DB
         https://github.com/ismyrnow/Leaflet.functionaltilelayer
     I compared the DB-based tiles layer with a purely local (localhost://)  
storage
     There is no noticeable difference in performance! between using  
IndexedDB and local files!

Results

     Chrome: Fetch (6.551s), Store (8.247s), Total Elapsed Time: (13.714s)
     FireFox: Fetch (0.422s), Store (31.519s), Total Elapsed Time: (32.836s)
     IE 10: Fetch (0.668s), Store: (0.896s), Total Elapsed Time: (3.758s)

Comment #51 on issue 108012 by d...@arandomurl.com: IndexedDB should  

support storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

Funnily in relation to #32 I have run into this while developing an in  
browser version of CouchDB (PouchDB)

The problem with polyfilling this with the filesystem api is that you lose  
transactional semantics on document writes, we need to refcount and do  
other such things when we write a document and when we break the event loop  
to store things on the filesystem we get interleaved reads a lot of invalid  
transaction objects.

It would be nice to see this fixed (alternatively I have heard that this  
isnt a popular idea but being able to open a transaction with an option to  
wait for it to be explicitly close would be just as good)

Comment #52 on issue 108012 by jsb...@chromium.org: IndexedDB should  

support storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

FYI, you can keep a transaction alive indefinitely by doing something like:

var keep_alive = true; // set to false to allow transaction to finish
var transaction; // the transaction to keep alive
var store = 'store name'; // some object store in scope

(function keepAlive() {
   if (keep_alive) {
     transaction.objectStore(store).get(0).onsuccess = keepAlive;
   }
}());

Comment #56 on issue 108012 by Florian....@gmail.com: IndexedDB should  

support storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

@cos...@gmail.com
Which solution are you using to store and read your videos ? (#42)
It tried using BinaryString for Chrome, but I don't succeed in converting  
string back to blob using your tip with Uint8Array(#44)

Do you have a working example somewhere ?
Thanks.

--
You received this message because this project is configured to send all  
issue notifications to this address.
You may adjust your notification preferences at:
https://code.google.com/hosting/settings

Comment #57 on issue 108012 by ju.carr...@gmail.com: IndexedDB should  

support storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

Yes, +1 for #56. I would love to see that as well.
Thanks guys!

Comment #61 on issue 108012 by ygutfre...@gmail.com: IndexedDB should  

support storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

Any status updates on when this will be resolved?

Comment #63 on issue 108012 by ygutfre...@gmail.com: IndexedDB should  

support storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

PouchDB  now supports native binary blob storage in the web client  
IndexedDB except in the case of Chrome (where it has to fall back to base64  
storage).

Comment #64 on issue 108012 by ygutfre...@gmail.com: IndexedDB should  

support storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

I have created a online demo "JSFIDDLE-Like" at:  
http://codepen.io/DrYSG/pen/hpqoD which uses XHR2 to fetch binary blobs,  
and stores them in PouchDB (which uses IndexedDB). PouchDB is currently  
converting the binary blobs to Base64. But it would be nice if Chrome  
supported native binary blobs in IDB.

Comment #65 on issue 108012 by ygutfre...@gmail.com: IndexedDB should  

support storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

Oh yes, to operate, fist delete the old database, then reload, then press  
download tiles. You will statistics as it runs, and an image fetched from  
IDB when it is done.

Comment #66 on issue 108012 by piranna: IndexedDB should support storing  
File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

There's currently any way to store File objects instead of Blobs? I'm
interested about storing references to the location of files added by the
user from the hard disk... Also, anybody know if it's supported to store
FileEntries and specially DirEntries?
El 29/05/2013 18:26, <chro...@googlecode.com> escribi�:

Comment #67 on issue 108012 by er...@chromium.org: IndexedDB should support  

storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

@piranna: IDB should support anything covered by the Structured Clone  
algorithm.  So once I get this feature in, it will support Blobs, Files,  
and FileLists.  It will not support FileEntry or DirEntry; it's not clear  
what exactly that would mean w.r.t. permissions, file lifetimes, etc., and  
the FileSystem spec isn't likely to see a lot of further development in the  
near term.

Comment #68 on issue 108012 by piranna: IndexedDB should support storing  
File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

Good to know. Seems that Mozilla is doing a copy of the File object instead
of maintain references to the original ones as according to the spec, is
this still true or files will be copied? I'm willing not...
El 29/05/2013 21:21, <chro...@googlecode.com> escribi�:

Comment #71 on issue 108012 by Toneti...@gmail.com: IndexedDB should  

support storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

Any new update??
I think this is a feature that many people are waiting..

Comment #73 on issue 108012 by downch...@gmail.com: IndexedDB should  

support storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

Chrome packaged apps now have a retain method for retaining access to  
filesystem entries. With those items as well as with standard FileSystem  
entries, you would simply store the URL reference in IndexedDB if you're  
looking to reference the FileEntry/DirectoryEntry. A Mozilla developer has  
started suggesting a new filesystem API, though there's little commitment.

Blob in IndexedDB still seems to be stalled. Use the FileSystem API and  
string references for the time being.

Comment #74 on issue 108012 by piranna: IndexedDB should support storing  
File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

I would like it to be a real web application, but until the Mozilla  
suggested filesystem API gets some progress, definitely using packaged apps  
on Chrome and DeviceStorage on Firefox would be a solution... :-) Thanks  
for your suggestion! :-D

Comment #75 on issue 108012 by ygutfre...@gmail.com: IndexedDB should  

support storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

in note #50 https://code.google.com/p/chromium/issues/detail?id=108012#c50,  
I indicate that I already tried the hybrid IDB/FileSystem approach (blobs  
in the FileSystem). It does work, but not as efficiently (performance) or  
maintainence free (you have to do your own folder load balancing, cleanup,  
etc.) So I am still hoping that what er...@cromiumum.org says in #69  
https://code.google.com/p/chromium/issues/detail?id=108012#c69 is true, and  
that the full IDB spec will be implemented (IE10 and IE11 does, *hint*  
*hint*) and their IDB is very very fast.

Comment #76 on issue 108012 by ygutfre...@gmail.com: IndexedDB should  

support storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

I have created another IDB download test. This one uses PouchDB (CouchDB  
for the browser and mobiles) and it uses IDB underneath. IE11 and FF have  
native blob support. Chrome is getting a slight performance hit since it  
does not.

1. Run http://codepen.io/DrYSG/pen/kdzft
2. Press [Download]

It will load 171 JPG map tiles via XHR2 and stored them in PouchDB (The  
table tells you if Binary or Base64 (Chrome) is being used in PouchDB).

[If you want to try with more JPG and get a higher resolution map (600+  
tiles) then FORK and change line 1 to
var serverURL  
= "https://googledrive.com/host/0B2Ay-nw1QSW2SHhjR0VBZXE2bUU/LittleBlueMarble/"  
]

You can also [DELETE] the PouchDB databases.

Please tell me what performance you see. Behind my firewalls I am getting  
about 24 Files/Sec. in IE11 and  22 Files/sec in Chrome.

One thing to know about this demo, is that it will only spawn "100 threads"  
of XHR2 download/IDB PUT). This is because of a issue  
https://code.google.com/p/chromium/issues/detail?id=244910

that I had to solve with throttling how fast Chrome downloads. You can  
easily FORK the source and  try different numbers of threads.


Also tell me if IE10 is working for you.

FireFox has a real poor IDB (an overlay of WebSQL, and no SPDY support, so  
performance is very very poor)

You can then look at the full downloaded map by going to:

http://codepen.io/DrYSG/pen/mcdCq

Comment #77 on issue 108012 by raymondc...@gmail.com: IndexedDB should  

support storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

This is the first time I've seen someone say Firefox's IDB implementation
is an overlay of WebSQL. I don't believe this is true. Do you have a source
for that?

Comment #78 on issue 108012 by ygutfre...@gmail.com: IndexedDB should  

support storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

Let me be more precise. FF uses SQLlite

1. http://www.aaron-powell.com/posts/2012-10-05-indexeddb-storage.html
2.  
http://stackoverflow.com/questions/9846013/how-to-view-indexeddb-content-in-firefox

This allows them to maintain legacy support of the WebSQL API, and also  
support IDB. But what I think I am finding is that non-SQL to a relational  
DB is not working well. (but maybe the real issue is lack of XHR2 and SPDY  
or something in their thread model) I really don't know. All I know is that  
Chrome does some amazing things in HTTP fetches pipeline.

Comment #79 on issue 108012 by piranna: IndexedDB should support storing  
File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

The usage of base64 is thanks to the hack someone posted on this issue
some months ago, or how it's done? If so, I would be interested on
take a look on it...

Comment #80 on issue 108012 by ce...@seznam.cz: IndexedDB should support  

storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

@78 ... just for the sake of completness. Firefox has never supported  
WebSQL, so there is no need to provide legacy support.

Comment #82 on issue 108012 by piranna: IndexedDB should support storing  
File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

Thanks for the advice. So, seems the storage of Blobs is not transparent,
isn't it?
El 20/08/2013 20:29, <chro...@googlecode.com> escribi�:

Comment #85 on issue 108012 by vitteaym...@gmail.com: IndexedDB should  

support storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

As mentioned in the thread this requires some fundamental changes but can  
we have an idea when this will work (months, years...)?

Updates:
        Cc: mlamo...@chromium.org

Comment #89 on issue 108012 by mlamo...@chromium.org: IndexedDB should  

support storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

(No comment was entered for this change.)

Updates:
        Cc: arthur...@chromium.org

Comment #90 on issue 108012 by dpa...@chromium.org: IndexedDB should  

Comment #91 on issue 108012 by vitteaym...@gmail.com: IndexedDB should  

support storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

Any news when this is coming?

Comment #92 on issue 108012 by mathieu....@matbee.com: IndexedDB should  

support storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

Anything?

Comment #93 on issue 108012 by bert...@gmail.com: IndexedDB should support  

storing File/Blob objects
http://code.google.com/p/chromium/issues/detail?id=108012

Just finishing a project without it, perverting filesystem and localstorage  
to work around this bug... Please, fix this