Media Galleries API: Audio/Video attached pictures support.

extensions/renderer/blob_native_handler.cc

 // Copyright 2014 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 "extensions/renderer/blob_native_handler.h"
 
 #include "base/bind.h"
+#include "third_party/WebKit/public/platform/Platform.h"
+#include "third_party/WebKit/public/platform/WebBlobRegistry.h"
 #include "third_party/WebKit/public/platform/WebCString.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/web/WebBlob.h"
 
 namespace {
 
 // Expects a single Blob argument. Returns the Blob's UUID.
 void GetBlobUuid(const v8::FunctionCallbackInfo<v8::Value>& args) {
   DCHECK_EQ(1, args.Length());
   blink::WebBlob blob = blink::WebBlob::fromV8Value(args[0]);
   args.GetReturnValue().Set(
       v8::String::NewFromUtf8(args.GetIsolate(), blob.uuid().utf8().data()));
 }
 
+// Take ownership of a Blob created on the browse process. Expects the Blob's
+// UUID, type, and size as arguments.
+void TakeBrowserProcessBlob(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  DCHECK_EQ(3, args.Length());
+  DCHECK(args[0]->IsString());
+  DCHECK(args[1]->IsString());
+  DCHECK(args[2]->IsInt32());
+  std::string uuid(*v8::String::Utf8Value(args[0]->ToString()));
+  std::string type(*v8::String::Utf8Value(args[1]->ToString()));
+  blink::WebBlob blob = blink::WebBlob::createFromUUID(
+      blink::WebString::fromUTF8(uuid), blink::WebString::fromUTF8(type),
+      args[2]->Int32Value());
+  args.GetReturnValue().Set(blob.toV8Value());
+
+  // Need to decrement the refcount to compensate for the extra count left over

[tommycli, 2014/04/29 23:29:26]

This is also janky, but necessary to keep the refcount straight, since the
browser process creates the Blob and needs to keep a ref to keep the Blob alive
long enough for this method to 'catch' the ball.

[michaeln, 2014/05/01 21:27:35]

This new case of creating a blob in the browser and sending it to the renderer
should use the pattern that's being used for IDB. That pattern involves an 'ack'
when the recipient has 'caught the ball' so the browser-side knows to drop its
handle. Here's the CL that shows how this is handled in IDB.

https://codereview.chromium.org/196473018/

The pattern goes like this:
- browser coins a blob and holds onto a scoped_ptr<BlobDataHandle>
- browser sends <uuid,type,size> to renderer
- renderer constructs blink::Blob (which establishes its own ref to uuid).
- renderer sends 'ack', got the blob
- browser deletes its BlobDataHandle

Additionally, if for any reason the renderer will never construct that
blink:Blob, the application has to delete BlobDataHandle. In cases like renderer
crashed, page unloaded prior to message getting that far, some other error in
processing prevented the blink::Blob from being coined.

+  // from the construction process in the browser side.
+  blink::Platform::current()->blobRegistry()->removeBlobDataRef(
+      blink::WebString::fromUTF8(uuid));
+}
+
 }  // namespace
 
 namespace extensions {
 
 BlobNativeHandler::BlobNativeHandler(ScriptContext* context)
     : ObjectBackedNativeHandler(context) {
   RouteFunction("GetBlobUuid", base::Bind(&GetBlobUuid));
+  RouteFunction("TakeBrowserProcessBlob", base::Bind(&TakeBrowserProcessBlob));
 }
 
 }  // namespace extensions