Run shim's watchForTag on document.DOMContentLoaded

chrome/renderer/extensions/render_view_observer_natives.cc

+// 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(content::RenderView* view,
+              v8::Handle<v8::Function> cb)
+      : content::RenderViewObserver(view),
+        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:
+  ScopedPersistent<v8::Function> callback_;
+
+  void CallbackAndDie(WebKit::WebFrame* frame, bool succeeded) {
+    v8::HandleScope handle_scope;
+    v8::Local<v8::Context> context = frame->mainWorldScriptContext();

[not at google - send to devlin, 2013/06/14 00:58:32]

I suspect it has something to do with this context switching here. Try the
following:

1. Pass the ChromeV8Context instance into this LoadWatcher class.
2. Delete basically all of this and just call
chrome_v8_context_->CallFunction(...) which does all the scoping for you.

no handle scope, context scope, etc. 

+    v8::Context::Scope scope(context);
+    v8::Local<v8::Object> global = context->Global();
+    {
+      WebKit::WebScopedMicrotaskSuppression suppression;
+      v8::Handle<v8::Value> args[] = {
+        succeeded ? v8::True() : v8::False()
+      };
+      callback_->Call(global, 1, args);

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

To answer your comment:

The problem I think is here. frame->mainWorldScriptContext is the context of the
frame which just loaded, not the frame that the callback was used in. It's
conceivable that this results in window.document being different, unexpectedly
(likely the "window" comes from the global of whatever context has been entered
i.e. is in scope).

If you were to save the calling context i.e. pass ChromeV8Context in here as I
suggested, then use v8::Context::Scope scope(context->v8_context()) then I think
it would work. Hopefully. That's something to try. However, this can all be

v8::HandleScope handle_scope;
context_->CallFunction(callback_, arraysize(args), args);

I think the reason it didn't work before is also because of this?

[lazyboy, 2013/06/14 16:23:32]

Why are there two frames? My assumption was the chrome/renderer/resources/...
JavaScript resources run on the same document (or should I say frame?) as the
one in created via chrome.app.window.create(), which I see is probably not true,
but wanted to know why.
It's
I'm using RenderViewObserverNative's context instead of mainWorldScriptContext,
now it doesn't crash as I'm creating the handle scope with the context as you
suggested, but I keep seeing the same behavior.

See latest logging changes in web_view.js, the app always sees documentB, the
renderer script sees documentA, I want to know when documentB's DOMContentLoaded
fires (that part is working with the change).

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

The first frame is the one that created the app window, the second is the one
inside the app window.

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