Run shim's watchForTag on document.DOMContentLoaded

chrome/renderer/extensions/render_view_observer_natives.cc

Index: chrome/renderer/extensions/render_view_observer_natives.cc
diff --git a/chrome/renderer/extensions/render_view_observer_natives.cc b/chrome/renderer/extensions/render_view_observer_natives.cc
new file mode 100644
index 0000000000000000000000000000000000000000..09e00b6893386d44f3525223f2f00160d7eaf244
--- /dev/null
+++ b/chrome/renderer/extensions/render_view_observer_natives.cc
@@ -0,0 +1,100 @@
+// Copyright 2013 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 "chrome/renderer/extensions/render_view_observer_natives.h"
+
+#include "chrome/common/extensions/api/extension_api.h"
+#include "chrome/renderer/extensions/dispatcher.h"
+#include "content/public/renderer/render_view.h"
+#include "content/public/renderer/render_view_observer.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebScopedMicrotaskSuppression.h"
+
+namespace extensions {
+
+namespace {
+class LoadWatcher : public content::RenderViewObserver {
+ public:
+  LoadWatcher(ChromeV8Context* context,
+              content::RenderView* view,
+              v8::Handle<v8::Function> cb)
+      : content::RenderViewObserver(view),
+        context_(context),
+        callback_(cb) {
+  }
+
+  virtual void DidCreateDocumentElement(WebKit::WebFrame* frame) OVERRIDE {
+    CallbackAndDie(frame, true);
+  }
+
+  virtual void DidFailProvisionalLoad(
+      WebKit::WebFrame* frame,
+      const WebKit::WebURLError& error) OVERRIDE {
+    CallbackAndDie(frame, false);
+  }
+
+ private:
+  ChromeV8Context* context_;
+  ScopedPersistent<v8::Function> callback_;
+
+  void CallbackAndDie(WebKit::WebFrame* frame, bool succeeded) {

[not at google - send to devlin, 2013/06/14 16:45:27]

frame not used

[lazyboy, 2013/06/14 18:17:34]

Done.

+    v8::HandleScope handle_scope;
+    v8::Context::Scope scope(context_->v8_context());

[not at google - send to devlin, 2013/06/14 16:45:27]

you don't need the scope, CallFunction does it for you

[lazyboy, 2013/06/14 18:17:34]

Done.

+    v8::Handle<v8::Value> args[] = {
+      succeeded ? v8::True() : v8::False()

[not at google - send to devlin, 2013/06/14 16:45:27]

v8::Boolean::New(succeeded)

[lazyboy, 2013/06/14 18:17:34]

Done.

+    };
+    context_->CallFunction(callback_.get(), 1, args);
+    delete this;
+  }
+};
+}  // namespace
+
+
+RenderViewObserverNatives::RenderViewObserverNatives(Dispatcher* dispatcher,
+                                                     ChromeV8Context* context)
+    : ChromeV8Extension(dispatcher, context) {
+  RouteFunction("OnDocumentCreated",
+                base::Bind(&RenderViewObserverNatives::OnDocumentCreated,
+                           base::Unretained(this)));
+  RouteFunction(
+      "OnDocumentCreatedForCurrentContext",
+      base::Bind(&RenderViewObserverNatives::OnDocumentCreatedForCurrentContext,
+                 base::Unretained(this)));
+}
+
+v8::Handle<v8::Value> RenderViewObserverNatives::OnDocumentCreated(
+    const v8::Arguments& args) {
+  CHECK(args.Length() == 2);
+  CHECK(args[0]->IsInt32());
+  CHECK(args[1]->IsFunction());
+
+  int view_id = args[0]->Int32Value();
+
+  content::RenderView* view = content::RenderView::FromRoutingID(view_id);
+  if (!view)
+    return v8::Undefined();
+
+  v8::Handle<v8::Function> func = v8::Handle<v8::Function>::Cast(args[1]);
+  new LoadWatcher(context(), view, func);
+
+  return v8::True();
+}
+
+v8::Handle<v8::Value>
+RenderViewObserverNatives::OnDocumentCreatedForCurrentContext(
+    const v8::Arguments& args) {
+  CHECK(args.Length() == 1);
+  CHECK(args[0]->IsFunction());
+
+  content::RenderView* view = context()->GetRenderView();
+  if (!view)

[not at google - send to devlin, 2013/06/14 16:45:27]

I think you can assume there's a render view here.

[lazyboy, 2013/06/14 18:17:34]

Done.

+    return v8::Undefined();
+
+  v8::Handle<v8::Function> func = v8::Handle<v8::Function>::Cast(args[0]);
+  new LoadWatcher(context(), view, func);
+
+  return v8::True();
+}
+
+}  // namespace extensions