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/public/web/WebFrame.h"
+#include "third_party/WebKit/public/web/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(true);
+  }
+
+  virtual void DidFailProvisionalLoad(
+      WebKit::WebFrame* frame,
+      const WebKit::WebURLError& error) OVERRIDE {
+    CallbackAndDie(false);
+  }
+
+ private:
+  ChromeV8Context* context_;
+  ScopedPersistent<v8::Function> callback_;
+
+  void CallbackAndDie(bool succeeded) {
+    v8::HandleScope handle_scope;
+    // Don't need Context::Scope, CallFunction does that for us.
+    v8::Handle<v8::Value> args[] = { v8::Boolean::New(succeeded) };
+    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)));
+}
+
+void RenderViewObserverNatives::OnDocumentCreated(
+    const v8::FunctionCallbackInfo<v8::Value>& 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::Handle<v8::Function> func = v8::Handle<v8::Function>::Cast(args[1]);
+  new LoadWatcher(context(), view, func);
+
+  args.GetReturnValue().Set(true);
+}
+
+void RenderViewObserverNatives::OnDocumentCreatedForCurrentContext(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
+  CHECK(args.Length() == 1);
+  CHECK(args[0]->IsFunction());
+
+  v8::Handle<v8::Function> func = v8::Handle<v8::Function>::Cast(args[0]);
+  new LoadWatcher(context(), context()->GetRenderView(), func);
+
+  args.GetReturnValue().Set(true);
+}
+
+}  // namespace extensions