Add a simple one shot and repeating timer API for Mojo.js.

gin/modules/timer.cc

Index: gin/modules/timer.cc
diff --git a/gin/modules/timer.cc b/gin/modules/timer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..9aaa68c1c4ed4292a18473d0a8df84a54addc034
--- /dev/null
+++ b/gin/modules/timer.cc
@@ -0,0 +1,94 @@
+// 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 "gin/modules/timer.h"
+
+#include "base/bind.h"
+#include "gin/object_template_builder.h"
+#include "gin/per_context_data.h"
+
+namespace gin {
+
+namespace {
+
+v8::Handle<v8::String> GetHiddenPropertyName(v8::Isolate* isolate) {
+  return gin::StringToSymbol(isolate, "::mojo::js::Timer");

[abarth-chromium, 2013/12/21 03:37:06]

::gin::Timer probably.  We don't want to mention "mojo" in this directory

+}

[abarth-chromium, 2013/12/21 03:37:06]

I talked with danno a bit about this pattern.  Apparently a better way to do
this is with v8::SymbolObject.  That way you can use the normal Get/Set
functions instead of the hidden values.  We'll probably want to switch over
eventually, but we don't need to do that now.

[Aaron Boodman, 2013/12/21 21:34:41]

Wow, cool. Note to self:
http://webreflection.blogspot.com/2013/03/simulating-es6-symbols-in-es5.html

[Aaron Boodman, 2013/12/21 22:02:18]

Actually, i'm still not clear on how that would work. Somebody needs to own the
Symbol or SymbolObject.

+
+}  // namespace
+
+// Timer
+
+gin::WrapperInfo Timer::kWrapperInfo = { gin::kEmbedderNativeGin };
+
+// static
+Handle<Timer> Timer::Create(TimerType type, v8::Isolate* isolate, int delay_ms,
+                            v8::Handle<v8::Function> function) {
+  return CreateHandle(isolate, new Timer(isolate, type == TYPE_REPEATING,
+                                         delay_ms, function));
+}
+
+ObjectTemplateBuilder Timer::GetObjectTemplateBuilder(v8::Isolate* isolate) {
+  return Wrappable<Timer>::GetObjectTemplateBuilder(isolate)
+      .SetMethod("cancel",
+                 base::Bind(&base::Timer::Stop, base::Unretained(&timer_)))
+      .SetMethod("reset",
+                 base::Bind(&base::Timer::Reset, base::Unretained(&timer_)));
+}
+
+Timer::Timer(v8::Isolate* isolate, bool repeating, int delay_ms,
+             v8::Handle<v8::Function> function)
+    : weak_factory_(this),
+      timer_(false, repeating),
+      runner_(PerContextData::From(
+          isolate->GetCurrentContext())->runner()->GetWeakPtr()) {
+  GetWrapper(runner_->isolate())->SetHiddenValue(GetHiddenPropertyName(isolate),
+                                                 function);
+  timer_.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(delay_ms),
+               base::Bind(&Timer::OnTimerFired, weak_factory_.GetWeakPtr()));
+}
+
+Timer::~Timer() {
+}
+
+void Timer::OnTimerFired() {
+  Runner::Scope scope(runner_.get());

[abarth-chromium, 2013/12/21 03:37:06]

Should we check the runner_ for null?

[Aaron Boodman, 2013/12/21 21:34:41]

I believe that cannot happen if everyone is playing by the rules:

If runner id deleted, then the isolate we are part of is deleted, which means
our wrapped object is deleted, which means this C++ object is deleted, which
means the weak callback we passed to the timer will not get called.

If someone keeps this object alive some other way, then we will get called, but
that person would be wrong.

Perhaps I should add a comment with this reasoning so that when this crashes we
can find the code that is incorrectly keeping us alive.

[Aaron Boodman, 2013/12/21 23:39:11]

I made a test for this to prove I was right. You were right.

https://codereview.chromium.org/100143006/

+  v8::Handle<v8::Function> function = v8::Handle<v8::Function>::Cast(
+      GetWrapper(runner_->isolate())->GetHiddenValue(
+          GetHiddenPropertyName(runner_->isolate())));
+  v8::Handle<v8::Value> argv[] = {};
+  runner_->Call(function, v8::Undefined(runner_->isolate()), 0, argv);
+}
+
+
+// TimerModule
+
+WrapperInfo TimerModule::kWrapperInfo = { kEmbedderNativeGin };
+
+// static
+Handle<TimerModule> TimerModule::Create(v8::Isolate* isolate) {
+  return CreateHandle(isolate, new TimerModule());
+}
+
+// static
+v8::Local<v8::Value> TimerModule::GetModule(v8::Isolate* isolate) {
+  return Create(isolate)->GetWrapper(isolate);
+}
+
+TimerModule::TimerModule() {
+}
+
+TimerModule::~TimerModule() {
+}
+
+ObjectTemplateBuilder TimerModule::GetObjectTemplateBuilder(
+    v8::Isolate* isolate) {
+  return Wrappable<TimerModule>::GetObjectTemplateBuilder(isolate)
+      .SetMethod("createOneShot",
+                 base::Bind(&Timer::Create, Timer::TYPE_ONE_SHOT))
+      .SetMethod("createRepeating",
+                 base::Bind(&Timer::Create, Timer::TYPE_REPEATING));
+}
+
+}  // namespace gin