Home | History | Annotate | Download | only in gin 
      1 // Copyright 2014 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 #include "gin/shell_runner.h"
      6 
      7 #include "gin/converter.h"
      8 #include "gin/modules/module_registry.h"
      9 #include "gin/per_context_data.h"
     10 #include "gin/public/context_holder.h"
     11 #include "gin/try_catch.h"
     12 
     13 using v8::Context;
     14 using v8::HandleScope;
     15 using v8::Isolate;
     16 using v8::Object;
     17 using v8::ObjectTemplate;
     18 using v8::Script;
     19 
     20 namespace gin {
     21 
     22 ShellRunnerDelegate::ShellRunnerDelegate() {
     23 }
     24 
     25 ShellRunnerDelegate::~ShellRunnerDelegate() {
     26 }
     27 
     28 v8::Handle<ObjectTemplate> ShellRunnerDelegate::GetGlobalTemplate(
     29     ShellRunner* runner,
     30     v8::Isolate* isolate) {
     31   return v8::Handle<ObjectTemplate>();
     32 }
     33 
     34 void ShellRunnerDelegate::DidCreateContext(ShellRunner* runner) {
     35 }
     36 
     37 void ShellRunnerDelegate::WillRunScript(ShellRunner* runner) {
     38 }
     39 
     40 void ShellRunnerDelegate::DidRunScript(ShellRunner* runner) {
     41 }
     42 
     43 void ShellRunnerDelegate::UnhandledException(ShellRunner* runner,
     44                                                TryCatch& try_catch) {
     45   CHECK(false) << try_catch.GetStackTrace();
     46 }
     47 
     48 ShellRunner::ShellRunner(ShellRunnerDelegate* delegate, Isolate* isolate)
     49     : delegate_(delegate) {
     50   v8::Isolate::Scope isolate_scope(isolate);
     51   HandleScope handle_scope(isolate);
     52   v8::Handle<v8::Context> context =
     53       Context::New(isolate, NULL, delegate_->GetGlobalTemplate(this, isolate));
     54 
     55   context_holder_.reset(new ContextHolder(isolate));
     56   context_holder_->SetContext(context);
     57   PerContextData::From(context)->set_runner(this);
     58 
     59   v8::Context::Scope scope(context);
     60   delegate_->DidCreateContext(this);
     61 }
     62 
     63 ShellRunner::~ShellRunner() {
     64 }
     65 
     66 void ShellRunner::Run(const std::string& source,
     67                       const std::string& resource_name) {
     68   TryCatch try_catch;
     69   v8::Isolate* isolate = GetContextHolder()->isolate();
     70   v8::Handle<Script> script = Script::Compile(
     71       StringToV8(isolate, source), StringToV8(isolate, resource_name));
     72   if (try_catch.HasCaught()) {
     73     delegate_->UnhandledException(this, try_catch);
     74     return;
     75   }
     76 
     77   Run(script);
     78 }
     79 
     80 v8::Handle<v8::Value> ShellRunner::Call(v8::Handle<v8::Function> function,
     81                                         v8::Handle<v8::Value> receiver,
     82                                         int argc,
     83                                         v8::Handle<v8::Value> argv[]) {
     84   TryCatch try_catch;
     85   delegate_->WillRunScript(this);
     86 
     87   v8::Handle<v8::Value> result = function->Call(receiver, argc, argv);
     88 
     89   delegate_->DidRunScript(this);
     90   if (try_catch.HasCaught())
     91     delegate_->UnhandledException(this, try_catch);
     92 
     93   return result;
     94 }
     95 
     96 ContextHolder* ShellRunner::GetContextHolder() {
     97   return context_holder_.get();
     98 }
     99 
    100 void ShellRunner::Run(v8::Handle<Script> script) {
    101   TryCatch try_catch;
    102   delegate_->WillRunScript(this);
    103 
    104   script->Run();
    105 
    106   delegate_->DidRunScript(this);
    107   if (try_catch.HasCaught()) {
    108     delegate_->UnhandledException(this, try_catch);
    109   }
    110 }
    111 
    112 }  // namespace gin
    113