Pass content-type resources to web intents. Goes through download, then invokes the p…

content/renderer/web_intents_host.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 "content/renderer/web_intents_host.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/utf_string_conversions.h"
 #include "content/common/intents_messages.h"
 #include "content/renderer/render_view_impl.h"
 #include "ipc/ipc_message.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebBindings.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebBlob.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebIntentRequest.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebCString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebSerializedScriptValue.h"
 #include "v8/include/v8.h"
 #include "webkit/glue/cpp_bound_class.h"
 
 using WebKit::WebBindings;
+using WebKit::WebBlob;
 using WebKit::WebCString;
 using WebKit::WebFrame;
 using WebKit::WebIntentRequest;
 using WebKit::WebString;
 using WebKit::WebSerializedScriptValue;
 
 // This class encapsulates the API the Intent object will expose to Javascript.
 // It is made available to the Javascript runtime in the service page using
 // NPAPI methods as with plugin/Javascript interaction objects and other
 // browser-provided Javascript API objects on |window|.
 class WebIntentsHost::BoundDeliveredIntent : public CppBoundClass {
  public:
   BoundDeliveredIntent(const webkit_glue::WebIntentData& intent,
                        WebIntentsHost* parent,
                        WebFrame* frame) {
     action_ = WebString(intent.action).utf8();
     type_ = WebString(intent.type).utf8();
+    extra_data_ = intent.extra_data;
     parent_ = parent;
 
     v8::HandleScope scope;
     v8::Local<v8::Context> ctx = frame->mainWorldScriptContext();
     v8::Context::Scope cscope(ctx);
     v8::Local<v8::Value> data_obj;
 
     if (intent.data_type == webkit_glue::WebIntentData::SERIALIZED) {
       WebSerializedScriptValue ssv =
           WebSerializedScriptValue::fromString(WebString(intent.data));
       DCHECK(!ssv.isNull());
       data_obj = v8::Local<v8::Value>::New(ssv.deserialize());
-    } else {
-      DCHECK(intent.data_type == webkit_glue::WebIntentData::UNSERIALIZED);
+    } else if (intent.data_type == webkit_glue::WebIntentData::UNSERIALIZED) {
       data_obj = v8::String::New(
           reinterpret_cast<const uint16_t*>(intent.unserialized_data.data()),
           static_cast<int>(intent.unserialized_data.length()));
+    } else {
+      DCHECK(intent.data_type == webkit_glue::WebIntentData::BLOB);
+      WebBlob web_blob = WebBlob::createFromFile(
+          WebString::fromUTF8(intent.blob_file), intent.blob_length);
+      data_obj = v8::Local<v8::Value>::New(web_blob.toV8Value());

[michaeln, 2012/03/29 20:51:57]

i have no clue if wrapping the return value of toV8Value() in a v8::Local does
;)

[Greg Billock, 2012/03/29 21:04:45]

Do I need to store this WebBlob in the object? That is, will stack allocating it
cause horror? My mental image was that toV8Value wraps the internal value, but
maybe that's not enough to make the lifespan right.

For simple values, it works out, but for this one, it may not (the handle
wouldn't be persisted to the toNPVariant binding onto the data_val_?

     }
 
     data_val_.reset(new CppVariant);
     WebBindings::toNPVariant(data_obj, frame->windowObject(), data_val_.get());
 
-    BindGetterCallback("action", base::Bind(&BoundDeliveredIntent::getAction,
+    BindGetterCallback("action", base::Bind(&BoundDeliveredIntent::GetAction,
                                             base::Unretained(this)));
-    BindGetterCallback("type", base::Bind(&BoundDeliveredIntent::getType,
+    BindGetterCallback("type", base::Bind(&BoundDeliveredIntent::GetType,
                                           base::Unretained(this)));
-    BindGetterCallback("data", base::Bind(&BoundDeliveredIntent::getData,
+    BindGetterCallback("data", base::Bind(&BoundDeliveredIntent::GetData,
                                           base::Unretained(this)));
-    BindCallback("postResult", base::Bind(&BoundDeliveredIntent::postResult,
+    BindCallback("getExtra", base::Bind(&BoundDeliveredIntent::GetExtra,
+                                        base::Unretained(this)));
+    BindCallback("postResult", base::Bind(&BoundDeliveredIntent::PostResult,
                                           base::Unretained(this)));
-    BindCallback("postFailure", base::Bind(&BoundDeliveredIntent::postFailure,
+    BindCallback("postFailure", base::Bind(&BoundDeliveredIntent::PostFailure,
                                            base::Unretained(this)));
   }
 
   virtual ~BoundDeliveredIntent() {
   }
 
   WebString SerializeCppVariant(const CppVariant& val) {
     v8::HandleScope scope;
     v8::Handle<v8::Value> v8obj = WebBindings::toV8Value(&val);
 
     WebSerializedScriptValue ssv =
         WebSerializedScriptValue::serialize(v8obj);
     if (ssv.isNull())
       return WebKit::WebString();
 
     return ssv.toString();
   }
 
-  void postResult(const CppArgumentList& args, CppVariant* retval) {
+  void PostResult(const CppArgumentList& args, CppVariant* retval) {
     if (args.size() != 1) {
       WebBindings::setException(NULL, "Must pass one argument to postResult");
       return;
     }
 
     WebString str = SerializeCppVariant(args[0]);
     parent_->OnResult(str);
   }
 
-  void postFailure(const CppArgumentList& args, CppVariant* retval) {
+  void PostFailure(const CppArgumentList& args, CppVariant* retval) {
     if (args.size() != 1) {
       WebBindings::setException(NULL, "Must pass one argument to postFailure");
       return;
     }
 
     WebString str = SerializeCppVariant(args[0]);
     parent_->OnFailure(str);
   }
 
-  void getAction(CppVariant* result) {
+  void GetAction(CppVariant* result) {
     std::string action;
     action.assign(action_.data(), action_.length());
     result->Set(action);
   }
 
-  void getType(CppVariant* result) {
+  void GetType(CppVariant* result) {
     std::string type;
     type.assign(type_.data(), type_.length());
     result->Set(type);
   }
 
-  void getData(CppVariant* result) {
+  void GetData(CppVariant* result) {
     result->Set(*data_val_.get());
   }
 
+  void GetExtra(const CppArgumentList& args, CppVariant* result) {
+    if (args.size() != 1) {
+      WebBindings::setException(NULL, "Must pass one argument to getExtra");
+      return;
+    }
+
+    WebString str = SerializeCppVariant(args[0]);
+    std::map<string16, string16>::const_iterator iter = extra_data_.find(str);
+    if (iter == extra_data_.end()) {
+      result->SetNull();
+      return;
+    }
+    std::string val = UTF16ToUTF8(iter->second);
+    result->Set(val);
+  }
+
  private:
   // Intent data suitable for surfacing to Javascript callers.
   WebCString action_;
   WebCString type_;
+  std::map<string16, string16> extra_data_;
   scoped_ptr<CppVariant> data_val_;
 
   // The dispatcher object, for forwarding postResult/postFailure calls.
   WebIntentsHost* parent_;
 };
 
 WebIntentsHost::WebIntentsHost(RenderViewImpl* render_view)
     : content::RenderViewObserver(render_view),
       id_counter_(0) {
 }
@@ skipping 57 matching lines @@
 // sub-frames. TODO(gbillock): This policy needs to be fine-tuned and
 // documented.
 void WebIntentsHost::DidClearWindowObject(WebFrame* frame) {
   if (intent_.get() == NULL || frame->top() != frame)
     return;
 
   delivered_intent_.reset(
       new BoundDeliveredIntent(*(intent_.get()), this, frame));
   delivered_intent_->BindToJavascript(frame, "intent");
 }