An internal intents dispatcher useful for initiating an intent from the browser process.

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 "content/common/intents_messages.h"
 #include "content/renderer/render_view_impl.h"
@@ skipping 13 matching lines @@
 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 string16& action,
-                       const string16& type,
-                       const string16& data,
+  BoundDeliveredIntent(const webkit_glue::WebIntentData& intent,
                        WebIntentsHost* parent,
                        WebFrame* frame) {
-    action_ = WebString(action).utf8();
-    type_ = WebString(type).utf8();
+    action_ = WebString(intent.action).utf8();
+    type_ = WebString(intent.type).utf8();
     parent_ = parent;
 
     v8::HandleScope scope;
     v8::Local<v8::Context> ctx = frame->mainWorldScriptContext();
     v8::Context::Scope cscope(ctx);
-    WebSerializedScriptValue ssv =
-        WebSerializedScriptValue::fromString(WebString(data));
-    // TODO(gbillock): use an exception handler instead? Need to
-    // pass back error state to caller? This is a pretty unexpected
-    // internal error...
-    CHECK(!ssv.isNull());
-    v8::Local<v8::Value> data_obj =
-        v8::Local<v8::Value>::New(ssv.deserialize());
+    v8::Local<v8::Value> data_obj;
+
+    if (intent.data_type == webkit_glue::WebIntentData::SERIALIZED) {
+      WebSerializedScriptValue ssv =
+          WebSerializedScriptValue::fromString(WebString(intent.data));
+      // TODO(gbillock): use an exception handler instead? Need to
+      // pass back error state to caller? This is a pretty unexpected
+      // internal error...
+      CHECK(!ssv.isNull());

[James Hawkins, 2012/03/12 23:19:11]

These should likely be DCHECKs.

[Greg Billock, 2012/03/12 23:52:22]

We're parsing something we ourselves serialized. If there's an error, it
probably means the data is corrupted. IOW, a serious error.

[James Hawkins, 2012/03/13 00:59:02]

DCHECK vs CHECK is not about severity.  CHECK should only be used to debug
crashes in the wild that cannot be repro'ed locally.

[Greg Billock, 2012/03/13 17:42:38]

DCHECK here will immediately mean a harder-to-diagnose crash in the next line.

On 2012/03/13 00:59:02, James Hawkins wrote:

[James Hawkins, 2012/03/13 18:22:03]

How is that?  They're the exact same except DCHECK is for debug-only builds.

We write DCHECKs in our code, make sure test coverage is high.  If we get
crashes in the wild, we add CHECKs to debug.  Having this as a CHECK while in
development isn't going to help anything and it's against the style guide for
the reasons I mentioned:

http://dev.chromium.org/developers/coding-style#TOC-CHECK-vs-DCHECK-and-NOTRE...

On 2012/03/13 17:42:38, Greg Billock wrote:

[Greg Billock, 2012/03/13 19:26:50]

If control continues when ssv.isNull, ssv.deserialize will crash. I'll leave the
DCHECK here to make that easier to spot in debug. It's pretty unexpected,
though.

+      data_obj = v8::Local<v8::Value>::New(ssv.deserialize());
+    } else {
+      CHECK(intent.data_type == webkit_glue::WebIntentData::UNSERIALIZED);
+      data_obj = v8::String::New(intent.unserialized_data.data(),
+                                 intent.unserialized_data.length());
+    }
 
     data_val_.reset(new CppVariant);
     WebBindings::toNPVariant(data_obj, frame->windowObject(), data_val_.get());
 
     BindGetterCallback("action", base::Bind(&BoundDeliveredIntent::getAction,
                                             base::Unretained(this)));
     BindGetterCallback("type", base::Bind(&BoundDeliveredIntent::getType,
                                           base::Unretained(this)));
     BindGetterCallback("data", base::Bind(&BoundDeliveredIntent::getData,
                                           base::Unretained(this)));
@@ skipping 124 matching lines @@
 }
 
 // We set the intent payload into all top-level frame window objects. This
 // should persist the data through redirects, and not deliver it to any
 // 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_->action, intent_->type, intent_->data, this, frame));
+  delivered_intent_.reset(
+      new BoundDeliveredIntent(*(intent_.get()), this, frame));
   delivered_intent_->BindToJavascript(frame, "intent");
 }