Move ModuleSystemTest and the tests that use it into extensions/.

extensions/renderer/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 "extensions/renderer/module_system_test.h"
+
+#include <map>
+#include <string>
 
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/stl_util.h"
 #include "base/strings/string_piece.h"
-#include "chrome/common/chrome_paths.h"
-#include "chrome/renderer/extensions/chrome_v8_context.h"
+#include "extensions/common/extension_paths.h"
 #include "extensions/renderer/logging_native_handler.h"
 #include "extensions/renderer/object_backed_native_handler.h"
 #include "extensions/renderer/safe_builtins.h"
 #include "extensions/renderer/utils_native_handler.h"
 #include "ui/base/resource/resource_bundle.h"
 
-#include <map>
-#include <string>
-
 using extensions::ModuleSystem;
 using extensions::NativeHandler;
 using extensions::ObjectBackedNativeHandler;
 
 namespace {
 
 class FailsOnException : public ModuleSystem::ExceptionHandler {
  public:
   virtual void HandleUncaughtException(const v8::TryCatch& try_catch) OVERRIDE {
     FAIL() << "Uncaught exception: " << CreateExceptionString(try_catch);
   }
 };
 
 class V8ExtensionConfigurator {
  public:
   V8ExtensionConfigurator()
       : safe_builtins_(extensions::SafeBuiltins::CreateV8Extension()),
         names_(1, safe_builtins_->name()),
         configuration_(new v8::ExtensionConfiguration(
-            names_.size(), vector_as_array(&names_))) {
+            static_cast<int>(names_.size()), vector_as_array(&names_))) {
     v8::RegisterExtension(safe_builtins_.get());
   }
 
   v8::ExtensionConfiguration* GetConfiguration() {
     return configuration_.get();
   }
 
  private:
   scoped_ptr<v8::Extension> safe_builtins_;
   std::vector<const char*> names_;
   scoped_ptr<v8::ExtensionConfiguration> configuration_;
 };
 
 base::LazyInstance<V8ExtensionConfigurator>::Leaky g_v8_extension_configurator =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 // Native JS functions for doing asserts.
 class ModuleSystemTestEnvironment::AssertNatives
     : public ObjectBackedNativeHandler {
  public:
-  explicit AssertNatives(extensions::ChromeV8Context* context)
+  explicit AssertNatives(extensions::ScriptContext* context)
       : ObjectBackedNativeHandler(context),
         assertion_made_(false),
         failed_(false) {
     RouteFunction("AssertTrue", base::Bind(&AssertNatives::AssertTrue,
         base::Unretained(this)));
     RouteFunction("AssertFalse", base::Bind(&AssertNatives::AssertFalse,
         base::Unretained(this)));
   }
 
   bool assertion_made() { return assertion_made_; }
@@ skipping 45 matching lines @@
 
 ModuleSystemTestEnvironment::ModuleSystemTestEnvironment(
     gin::IsolateHolder* isolate_holder)
     : isolate_holder_(isolate_holder),
       context_holder_(new gin::ContextHolder(isolate_holder_->isolate())),
       handle_scope_(isolate_holder_->isolate()),
       source_map_(new StringSourceMap()) {
   context_holder_->SetContext(
       v8::Context::New(isolate_holder->isolate(),
                        g_v8_extension_configurator.Get().GetConfiguration()));
-  context_.reset(new extensions::ChromeV8Context(
+  context_.reset(new extensions::ScriptContext(
       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()));
@@ skipping 31 matching lines @@
     const std::string& name,
     const std::string& code) {
   RegisterModule(name, code);
   context_->module_system()->OverrideNativeHandlerForTest(name);
 }
 
 void ModuleSystemTestEnvironment::RegisterTestFile(
     const std::string& module_name,
     const std::string& file_name) {
   base::FilePath test_js_file_path;
-  ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_js_file_path));
-  test_js_file_path = test_js_file_path.AppendASCII("extensions")
-                                       .AppendASCII(file_name);
+  ASSERT_TRUE(PathService::Get(extensions::DIR_TEST_DATA, &test_js_file_path));
+  test_js_file_path = test_js_file_path.AppendASCII(file_name);
   std::string test_js;
   ASSERT_TRUE(base::ReadFileToString(test_js_file_path, &test_js));
   source_map_->RegisterModule(module_name, test_js);
 }
 
 void ModuleSystemTestEnvironment::ShutdownGin() {
   context_holder_.reset();
 }
 
 void ModuleSystemTestEnvironment::ShutdownModuleSystem() {
@@ skipping 31 matching lines @@
   return make_scoped_ptr(new ModuleSystemTestEnvironment(&isolate_holder_));
 }
 
 void ModuleSystemTest::ExpectNoAssertionsMade() {
   should_assertions_be_made_ = false;
 }
 
 void ModuleSystemTest::RunResolvedPromises() {
   isolate_holder_.isolate()->RunMicrotasks();
 }