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 "extensions/renderer/module_system_test.h"
6
7#include <map>
8#include <string>
9
10#include "base/callback.h"
11#include "base/files/file_path.h"
12#include "base/files/file_util.h"
13#include "base/lazy_instance.h"
14#include "base/memory/scoped_ptr.h"
15#include "base/path_service.h"
16#include "base/stl_util.h"
17#include "base/strings/string_piece.h"
18#include "extensions/common/extension_paths.h"
19#include "extensions/renderer/logging_native_handler.h"
20#include "extensions/renderer/object_backed_native_handler.h"
21#include "extensions/renderer/safe_builtins.h"
22#include "extensions/renderer/utils_native_handler.h"
23#include "ui/base/resource/resource_bundle.h"
24
25namespace extensions {
26namespace {
27
28class FailsOnException : public ModuleSystem::ExceptionHandler {
29 public:
30  virtual void HandleUncaughtException(const v8::TryCatch& try_catch) OVERRIDE {
31    FAIL() << "Uncaught exception: " << CreateExceptionString(try_catch);
32  }
33};
34
35class V8ExtensionConfigurator {
36 public:
37  V8ExtensionConfigurator()
38      : safe_builtins_(SafeBuiltins::CreateV8Extension()),
39        names_(1, safe_builtins_->name()),
40        configuration_(
41            new v8::ExtensionConfiguration(static_cast<int>(names_.size()),
42                                           vector_as_array(&names_))) {
43    v8::RegisterExtension(safe_builtins_.get());
44  }
45
46  v8::ExtensionConfiguration* GetConfiguration() {
47    return configuration_.get();
48  }
49
50 private:
51  scoped_ptr<v8::Extension> safe_builtins_;
52  std::vector<const char*> names_;
53  scoped_ptr<v8::ExtensionConfiguration> configuration_;
54};
55
56base::LazyInstance<V8ExtensionConfigurator>::Leaky g_v8_extension_configurator =
57    LAZY_INSTANCE_INITIALIZER;
58
59}  // namespace
60
61// Native JS functions for doing asserts.
62class ModuleSystemTestEnvironment::AssertNatives
63    : public ObjectBackedNativeHandler {
64 public:
65  explicit AssertNatives(ScriptContext* context)
66      : ObjectBackedNativeHandler(context),
67        assertion_made_(false),
68        failed_(false) {
69    RouteFunction(
70        "AssertTrue",
71        base::Bind(&AssertNatives::AssertTrue, base::Unretained(this)));
72    RouteFunction(
73        "AssertFalse",
74        base::Bind(&AssertNatives::AssertFalse, base::Unretained(this)));
75  }
76
77  bool assertion_made() { return assertion_made_; }
78  bool failed() { return failed_; }
79
80  void AssertTrue(const v8::FunctionCallbackInfo<v8::Value>& args) {
81    CHECK_EQ(1, args.Length());
82    assertion_made_ = true;
83    failed_ = failed_ || !args[0]->ToBoolean()->Value();
84  }
85
86  void AssertFalse(const v8::FunctionCallbackInfo<v8::Value>& args) {
87    CHECK_EQ(1, args.Length());
88    assertion_made_ = true;
89    failed_ = failed_ || args[0]->ToBoolean()->Value();
90  }
91
92 private:
93  bool assertion_made_;
94  bool failed_;
95};
96
97// Source map that operates on std::strings.
98class ModuleSystemTestEnvironment::StringSourceMap
99    : public ModuleSystem::SourceMap {
100 public:
101  StringSourceMap() {}
102  virtual ~StringSourceMap() {}
103
104  virtual v8::Handle<v8::Value> GetSource(v8::Isolate* isolate,
105                                          const std::string& name) OVERRIDE {
106    if (source_map_.count(name) == 0)
107      return v8::Undefined(isolate);
108    return v8::String::NewFromUtf8(isolate, source_map_[name].c_str());
109  }
110
111  virtual bool Contains(const std::string& name) OVERRIDE {
112    return source_map_.count(name);
113  }
114
115  void RegisterModule(const std::string& name, const std::string& source) {
116    CHECK_EQ(0u, source_map_.count(name)) << "Module " << name << " not found";
117    source_map_[name] = source;
118  }
119
120 private:
121  std::map<std::string, std::string> source_map_;
122};
123
124ModuleSystemTestEnvironment::ModuleSystemTestEnvironment(v8::Isolate* isolate)
125    : isolate_(isolate),
126      context_holder_(new gin::ContextHolder(isolate_)),
127      handle_scope_(isolate_),
128      source_map_(new StringSourceMap()) {
129  context_holder_->SetContext(v8::Context::New(
130      isolate, g_v8_extension_configurator.Get().GetConfiguration()));
131  context_.reset(new ScriptContext(context_holder_->context(),
132                                   NULL,  // WebFrame
133                                   NULL,  // Extension
134                                   Feature::BLESSED_EXTENSION_CONTEXT,
135                                   NULL,  // Effective Extension
136                                   Feature::BLESSED_EXTENSION_CONTEXT));
137  context_->v8_context()->Enter();
138  assert_natives_ = new AssertNatives(context_.get());
139
140  {
141    scoped_ptr<ModuleSystem> module_system(
142        new ModuleSystem(context_.get(), source_map_.get()));
143    context_->set_module_system(module_system.Pass());
144  }
145  ModuleSystem* module_system = context_->module_system();
146  module_system->RegisterNativeHandler(
147      "assert", scoped_ptr<NativeHandler>(assert_natives_));
148  module_system->RegisterNativeHandler(
149      "logging",
150      scoped_ptr<NativeHandler>(new LoggingNativeHandler(context_.get())));
151  module_system->RegisterNativeHandler(
152      "utils",
153      scoped_ptr<NativeHandler>(new UtilsNativeHandler(context_.get())));
154  module_system->SetExceptionHandlerForTest(
155      scoped_ptr<ModuleSystem::ExceptionHandler>(new FailsOnException));
156}
157
158ModuleSystemTestEnvironment::~ModuleSystemTestEnvironment() {
159  if (context_)
160    context_->v8_context()->Exit();
161}
162
163void ModuleSystemTestEnvironment::RegisterModule(const std::string& name,
164                                                 const std::string& code) {
165  source_map_->RegisterModule(name, code);
166}
167
168void ModuleSystemTestEnvironment::RegisterModule(const std::string& name,
169                                                 int resource_id) {
170  const std::string& code = ResourceBundle::GetSharedInstance()
171                                .GetRawDataResource(resource_id)
172                                .as_string();
173  source_map_->RegisterModule(name, code);
174}
175
176void ModuleSystemTestEnvironment::OverrideNativeHandler(
177    const std::string& name,
178    const std::string& code) {
179  RegisterModule(name, code);
180  context_->module_system()->OverrideNativeHandlerForTest(name);
181}
182
183void ModuleSystemTestEnvironment::RegisterTestFile(
184    const std::string& module_name,
185    const std::string& file_name) {
186  base::FilePath test_js_file_path;
187  ASSERT_TRUE(PathService::Get(DIR_TEST_DATA, &test_js_file_path));
188  test_js_file_path = test_js_file_path.AppendASCII(file_name);
189  std::string test_js;
190  ASSERT_TRUE(base::ReadFileToString(test_js_file_path, &test_js));
191  source_map_->RegisterModule(module_name, test_js);
192}
193
194void ModuleSystemTestEnvironment::ShutdownGin() {
195  context_holder_.reset();
196}
197
198void ModuleSystemTestEnvironment::ShutdownModuleSystem() {
199  context_->v8_context()->Exit();
200  context_.reset();
201}
202
203v8::Handle<v8::Object> ModuleSystemTestEnvironment::CreateGlobal(
204    const std::string& name) {
205  v8::EscapableHandleScope handle_scope(isolate_);
206  v8::Local<v8::Object> object = v8::Object::New(isolate_);
207  isolate_->GetCurrentContext()->Global()->Set(
208      v8::String::NewFromUtf8(isolate_, name.c_str()), object);
209  return handle_scope.Escape(object);
210}
211
212ModuleSystemTest::ModuleSystemTest()
213    : isolate_(v8::Isolate::GetCurrent()),
214      should_assertions_be_made_(true) {
215}
216
217ModuleSystemTest::~ModuleSystemTest() {
218}
219
220void ModuleSystemTest::SetUp() {
221  env_ = CreateEnvironment();
222}
223
224void ModuleSystemTest::TearDown() {
225  // All tests must assert at least once unless otherwise specified.
226  EXPECT_EQ(should_assertions_be_made_,
227            env_->assert_natives()->assertion_made());
228  EXPECT_FALSE(env_->assert_natives()->failed());
229  env_.reset();
230  v8::HeapStatistics stats;
231  isolate_->GetHeapStatistics(&stats);
232  size_t old_heap_size = 0;
233  // Run the GC until the heap size reaches a steady state to ensure that
234  // all the garbage is collected.
235  while (stats.used_heap_size() != old_heap_size) {
236    old_heap_size = stats.used_heap_size();
237    isolate_->RequestGarbageCollectionForTesting(
238        v8::Isolate::kFullGarbageCollection);
239    isolate_->GetHeapStatistics(&stats);
240  }
241}
242
243scoped_ptr<ModuleSystemTestEnvironment> ModuleSystemTest::CreateEnvironment() {
244  return make_scoped_ptr(new ModuleSystemTestEnvironment(isolate_));
245}
246
247void ModuleSystemTest::ExpectNoAssertionsMade() {
248  should_assertions_be_made_ = false;
249}
250
251void ModuleSystemTest::RunResolvedPromises() {
252  isolate_->RunMicrotasks();
253}
254
255}  // namespace extensions
256