Add support for AMD to the extensions module system.

chrome/test/base/module_system_test.cc

 // Copyright (c) 2012 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/test/base/module_system_test.h"
 
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
@@ skipping 103 matching lines @@
   void RegisterModule(const std::string& name, const std::string& source) {
     CHECK_EQ(0u, source_map_.count(name)) << "Module " << name << " not found";
     source_map_[name] = source;
   }
 
  private:
   std::map<std::string, std::string> source_map_;
 };
 
 ModuleSystemTest::ModuleSystemTest()
-    : isolate_(v8::Isolate::GetCurrent()),
-      handle_scope_(isolate_),
-      context_(
-          new extensions::ChromeV8Context(
-              v8::Context::New(
-                  isolate_,
-                  g_v8_extension_configurator.Get().GetConfiguration()),
-              NULL,  // WebFrame
-              NULL,  // Extension
-              extensions::Feature::UNSPECIFIED_CONTEXT)),
+    : isolate_holder_(v8::Isolate::GetCurrent(), NULL),
+      context_holder_(isolate_holder_.isolate()),
+      handle_scope_(isolate_holder_.isolate()),
       source_map_(new StringSourceMap()),
       should_assertions_be_made_(true) {
+  context_holder_.SetContext(
+      v8::Context::New(isolate_holder_.isolate(),
+                       g_v8_extension_configurator.Get().GetConfiguration()));
+  context_.reset(new extensions::ChromeV8Context(
+      context_holder_.context(),
+      NULL,  // WebFrame
+      NULL,  // Extension
+      extensions::Feature::UNSPECIFIED_CONTEXT));
   context_->v8_context()->Enter();
   assert_natives_ = new AssertNatives(context_.get());
 
   {
     scoped_ptr<ModuleSystem> module_system(
         new ModuleSystem(context_.get(), source_map_.get()));
     context_->set_module_system(module_system.Pass());
   }
   ModuleSystem* module_system = context_->module_system();
   module_system->RegisterNativeHandler("assert", scoped_ptr<NativeHandler>(
       assert_natives_));
   module_system->RegisterNativeHandler("logging", scoped_ptr<NativeHandler>(
       new extensions::LoggingNativeHandler(context_.get())));
-  module_system->RegisterNativeHandler("utils", scoped_ptr<NativeHandler>(
-      new extensions::UtilsNativeHandler(context_.get())));
+  module_system->RegisterNativeHandler(
+      "utils_natives",
+      scoped_ptr<NativeHandler>(
+          new extensions::UtilsNativeHandler(context_.get())));
   module_system->SetExceptionHandlerForTest(
       scoped_ptr<ModuleSystem::ExceptionHandler>(new FailsOnException));
 }
 
 ModuleSystemTest::~ModuleSystemTest() {
   context_->v8_context()->Exit();
 }
 
 void ModuleSystemTest::RegisterModule(const std::string& name,
                                       const std::string& code) {
@@ skipping 36 matching lines @@
 }
 
 v8::Handle<v8::Object> ModuleSystemTest::CreateGlobal(const std::string& name) {
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   v8::EscapableHandleScope handle_scope(isolate);
   v8::Local<v8::Object> object = v8::Object::New(isolate);
   isolate->GetCurrentContext()->Global()->Set(
       v8::String::NewFromUtf8(isolate, name.c_str()), object);
   return handle_scope.Escape(object);
 }