Add API to construct new vector interchange MIME data type.

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/public/renderer/v8_value_converter.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/WebDeliveredIntentClient.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebIntent.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebIntentRequest.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
@@ skipping 102 matching lines @@
 // TODO(gbillock): match to spec to double-check registration match before
 // delivery.
 void WebIntentsHost::DidClearWindowObject(WebFrame* frame) {
   if (intent_.get() == NULL || frame->top() != frame)
     return;
 
   if (!delivered_intent_client_.get()) {
     delivered_intent_client_.reset(new DeliveredIntentClientImpl(this));
   }
 
-  WebVector<WebString> extras_keys(intent_->extra_data.size());
-  WebVector<WebString> extras_values(intent_->extra_data.size());
-  std::map<string16, string16>::iterator iter;
-  int i;
-  for (i = 0, iter = intent_->extra_data.begin();
-       iter != intent_->extra_data.end();
+  v8::HandleScope scope;
+  v8::Local<v8::Context> ctx = frame->mainWorldScriptContext();
+  v8::Context::Scope cscope(ctx);
+  WebIntent web_intent = CreateWebIntent(frame, *(intent_.get()));
+
+  if (!web_intent.action().isEmpty())
+    frame->deliverIntent(web_intent, NULL, delivered_intent_client_.get());
+}
+
+// Must be called with v8 scope held.

[groby-ooo-7-16, 2012/10/08 19:01:04]

Can we DCHECK for that?

[Greg Billock, 2012/10/08 21:26:35]

I think I got the right thing here now.

On 2012/10/08 19:01:04, groby wrote:

+WebIntent WebIntentsHost::CreateWebIntent(
+    WebFrame* frame, const webkit_glue::WebIntentData& intent_data) {
+  // TODO(gbillock): Remove this block when we get rid of |extras|.
+  WebVector<WebString> extras_keys(intent_data.extra_data.size());
+  WebVector<WebString> extras_values(intent_data.extra_data.size());
+  std::map<string16, string16>::const_iterator iter;
+  size_t i;
+  for (i = 0, iter = intent_data.extra_data.begin();
+       iter != intent_data.extra_data.end();
        ++i, ++iter) {
     extras_keys[i] = iter->first;
     extras_values[i] = iter->second;
   }
 
-  v8::HandleScope scope;
-  v8::Local<v8::Context> ctx = frame->mainWorldScriptContext();
-  v8::Context::Scope cscope(ctx);
-  WebIntent web_intent;
-
-  if (intent_->data_type == webkit_glue::WebIntentData::SERIALIZED) {
-    web_intent = WebIntent::create(intent_->action, intent_->type,
-                                   intent_->data,
-                                   extras_keys, extras_values);
-  } else if (intent_->data_type == webkit_glue::WebIntentData::UNSERIALIZED) {
+  if (intent_data.data_type == webkit_glue::WebIntentData::SERIALIZED) {
+    return WebIntent::create(intent_data.action, intent_data.type,
+                             intent_data.data,
+                             extras_keys, extras_values);
+  } else if (intent_data.data_type ==
+             webkit_glue::WebIntentData::UNSERIALIZED) {
     v8::Local<v8::String> dataV8 = v8::String::New(
-        reinterpret_cast<const uint16_t*>(intent_->unserialized_data.data()),
-        static_cast<int>(intent_->unserialized_data.length()));
+        reinterpret_cast<const uint16_t*>(intent_data.unserialized_data.data()),
+        static_cast<int>(intent_data.unserialized_data.length()));
     WebSerializedScriptValue serialized_data =
         WebSerializedScriptValue::serialize(dataV8);
 
-    web_intent = WebIntent::create(intent_->action, intent_->type,
-                                   serialized_data.toString(),
-                                   extras_keys, extras_values);
-  } else if (intent_->data_type == webkit_glue::WebIntentData::BLOB) {
-    DCHECK(intent_->data_type == webkit_glue::WebIntentData::BLOB);
+    return WebIntent::create(intent_data.action, intent_data.type,
+                             serialized_data.toString(),
+                             extras_keys, extras_values);
+  } else if (intent_data.data_type == webkit_glue::WebIntentData::BLOB) {
     web_blob_ = WebBlob::createFromFile(
-        WebString::fromUTF8(intent_->blob_file.AsUTF8Unsafe()),
-        intent_->blob_length);
+        WebString::fromUTF8(intent_data.blob_file.AsUTF8Unsafe()),
+        intent_data.blob_length);
     WebSerializedScriptValue serialized_data =
         WebSerializedScriptValue::serialize(web_blob_.toV8Value());
-    web_intent = WebIntent::create(intent_->action, intent_->type,
-                                   serialized_data.toString(),
-                                   extras_keys, extras_values);
-  } else if (intent_->data_type == webkit_glue::WebIntentData::FILESYSTEM) {
+    return WebIntent::create(intent_data.action, intent_data.type,
+                             serialized_data.toString(),
+                             extras_keys, extras_values);
+  } else if (intent_data.data_type == webkit_glue::WebIntentData::FILESYSTEM) {
     const GURL origin = GURL(frame->document().securityOrigin().toString());
     const GURL root_url =
         fileapi::GetFileSystemRootURI(origin, fileapi::kFileSystemTypeIsolated);
     const std::string url = base::StringPrintf(
         "%s%s/%s/",
         root_url.spec().c_str(),
-        intent_->filesystem_id.c_str(),
-        intent_->root_name.c_str());
+        intent_data.filesystem_id.c_str(),
+        intent_data.root_name.c_str());
     // TODO(kmadhusu): This is a temporary hack to create a serializable file
     // system. Once we have a better way to create a serializable file system,
     // remove this hack.
     v8::Handle<v8::Value> filesystem_V8 = frame->createSerializableFileSystem(
         WebKit::WebFileSystem::TypeIsolated,
-        WebKit::WebString::fromUTF8(intent_->root_name),
+        WebKit::WebString::fromUTF8(intent_data.root_name),
         WebKit::WebString::fromUTF8(url));
     WebSerializedScriptValue serialized_data =
         WebSerializedScriptValue::serialize(filesystem_V8);
-    web_intent = WebIntent::create(intent_->action, intent_->type,
-                                   serialized_data.toString(),
-                                   extras_keys, extras_values);
+    return WebIntent::create(intent_data.action, intent_data.type,

[groby-ooo-7-16, 2012/10/08 19:01:04]

serialize/create is still shared across a lot of the code... I'd love it if we
could factor that out.

[Greg Billock, 2012/10/08 21:26:35]

The trouble is the |data| -- I think we'll end up making extra copies if we
factor it out. Still think we should?

On 2012/10/08 19:01:04, groby wrote:

+                             serialized_data.toString(),
+                             extras_keys, extras_values);
+  } else if (intent_data.data_type == webkit_glue::WebIntentData::MIME_TYPE) {
+    scoped_ptr<content::V8ValueConverter> converter(
+        content::V8ValueConverter::create());
+    v8::Handle<v8::Array> dataV8 =
+        v8::Array::New(intent_data.mime_data.GetSize());
+    size_t j;
+    for (j = 0; j < intent_data.mime_data.GetSize(); ++j) {
+      const DictionaryValue* val;
+      if (!intent_data.mime_data.GetDictionary(j, &val)) continue;
+      v8::Local<v8::Context> ctx = frame->mainWorldScriptContext();
+      v8::Handle<v8::Value> data_point_value =
+          converter->ToV8Value(val, ctx);
+      if (!data_point_value->IsObject()) continue;
+      v8::Handle<v8::Object> data_point = data_point_value->ToObject();
+      if (j == 0 && !intent_data.blob_file.empty()) {
+        // If we are carrying blob data, convert it to v8 format
+        // and set it to the "blob" property of |data_point|.
+        web_blob_ = WebBlob::createFromFile(
+            WebString::fromUTF8(intent_data.blob_file.AsUTF8Unsafe()),
+            intent_data.blob_length);
+        v8::Local<v8::String> blob_v8_key = v8::String::New("blob", 4);
+        data_point->Set(blob_v8_key, web_blob_.toV8Value());
+      }
+      dataV8->Set(j, data_point);
+    }
+
+    WebSerializedScriptValue serialized_data =
+        WebSerializedScriptValue::serialize(dataV8);
+    return WebIntent::create(intent_data.action, intent_data.type,
+                             serialized_data.toString(),
+                             WebVector<WebString>(), WebVector<WebString>());
   } else {
     NOTREACHED();
+    return WebIntent();

[groby-ooo-7-16, 2012/10/08 19:01:04]

Let's take out the whole else branch and just NOTREACHED/return?

[Greg Billock, 2012/10/08 21:26:35]

Done.

   }
-
-  if (!web_intent.action().isEmpty())
-    frame->deliverIntent(web_intent, NULL, delivered_intent_client_.get());
 }