runner.h revision d57369da7c6519fef57db42085f7b42d4c8845c1 
1// Copyright 2013 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#ifndef GIN_RUNNER_H_
6#define GIN_RUNNER_H_
7
8#include <string>
9
10#include "base/memory/weak_ptr.h"
11#include "gin/gin_export.h"
12#include "gin/public/context_holder.h"
13
14namespace gin {
15
16class Runner;
17class TryCatch;
18
19// Subclass RunnerDelegate to customize the behavior of |Runner|. Typical
20// embedders will want to subclass one of the specialized RunnerDelegates,
21// such as ModuleRunnerDelegate.
22class GIN_EXPORT RunnerDelegate {
23 public:
24  RunnerDelegate();
25  virtual ~RunnerDelegate();
26
27  // Returns the template for the global object.
28  virtual v8::Handle<v8::ObjectTemplate> GetGlobalTemplate(Runner* runner);
29  virtual void DidCreateContext(Runner* runner);
30  virtual void WillRunScript(Runner* runner);
31  virtual void DidRunScript(Runner* runner);
32  virtual void UnhandledException(Runner* runner, TryCatch& try_catch);
33};
34
35// Runner lets you run code in a v8::Context. Upon construction, Runner will
36// create a v8::Context. Upon destruction, Runner will dispose the context.
37class GIN_EXPORT Runner : public ContextHolder {
38 public:
39  Runner(RunnerDelegate* delegate, v8::Isolate* isolate);
40  ~Runner();
41
42  // Before running script in this context, you'll need to enter the runner's
43  // context by creating an instance of Runner::Scope on the stack.
44  void Run(const std::string& source, const std::string& resource_name);
45  void Run(v8::Handle<v8::Script> script);
46
47  v8::Handle<v8::Value> Call(v8::Handle<v8::Function> function,
48                             v8::Handle<v8::Value> receiver,
49                             int argc,
50                             v8::Handle<v8::Value> argv[]);
51
52  v8::Handle<v8::Object> global() const {
53    return context()->Global();
54  }
55
56  // Useful for running script in this context asynchronously. Rather than
57  // holding a raw pointer to the runner, consider holding a WeakPtr.
58  base::WeakPtr<Runner> GetWeakPtr() {
59    return weak_factory_.GetWeakPtr();
60  }
61
62  class GIN_EXPORT Scope {
63   public:
64    explicit Scope(Runner* runner);
65    ~Scope();
66
67   private:
68    v8::Isolate::Scope isolate_scope_;
69    v8::HandleScope handle_scope_;
70    v8::Context::Scope scope_;
71
72    DISALLOW_COPY_AND_ASSIGN(Scope);
73  };
74
75 private:
76  friend class Scope;
77
78  RunnerDelegate* delegate_;
79
80  base::WeakPtrFactory<Runner> weak_factory_;
81
82  DISALLOW_COPY_AND_ASSIGN(Runner);
83};
84
85}  // namespace gin
86
87#endif  // GIN_RUNNER_H_
88