Attempting to fix problems in 11571014.

chrome/renderer/extensions/module_system.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/renderer/extensions/module_system.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
+#include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/renderer/extensions/chrome_v8_context.h"
 #include "content/public/renderer/render_view.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebScopedMicrotaskSuppression.h"
 
 namespace {
 
 const char* kModuleSystem = "module_system";
 const char* kModuleName = "module_name";
 const char* kModuleField = "module_field";
 const char* kModulesField = "modules";
 
 } // namespace
 
 namespace extensions {
 
 ModuleSystem::ModuleSystem(v8::Handle<v8::Context> context,
                            SourceMap* source_map)
     : ObjectBackedNativeHandler(context),
       source_map_(source_map),
-      natives_enabled_(0),
-      is_valid_(true) {
+      natives_enabled_(0) {
   RouteFunction("require",
       base::Bind(&ModuleSystem::RequireForJs, base::Unretained(this)));
   RouteFunction("requireNative",
       base::Bind(&ModuleSystem::RequireNative, base::Unretained(this)));
 
   v8::Handle<v8::Object> global(context->Global());
   global->SetHiddenValue(v8::String::New(kModulesField), v8::Object::New());
   global->SetHiddenValue(v8::String::New(kModuleSystem),
                          v8::External::New(this));
 }
 
 ModuleSystem::~ModuleSystem() {
   Invalidate();
 }
 
-bool ModuleSystem::Invalidate() {
-  if (!ObjectBackedNativeHandler::Invalidate())
-    return false;
-
-  v8::HandleScope handle_scope;
-  // Deleting this value here prevents future lazy field accesses from
-  // referencing ModuleSystem after it has been freed.
-  v8_context()->Global()->DeleteHiddenValue(v8::String::New(kModuleSystem));
-
-  return true;
+void ModuleSystem::Invalidate() {
+  if (!is_valid())
+    return;
+  for (NativeHandlerMap::iterator it = native_handler_map_.begin();
+       it != native_handler_map_.end(); ++it) {
+    it->second->Invalidate();
+  }
+  ObjectBackedNativeHandler::Invalidate();
 }
 
 ModuleSystem::NativesEnabledScope::NativesEnabledScope(
     ModuleSystem* module_system)
     : module_system_(module_system) {
   module_system_->natives_enabled_++;
 }
 
 ModuleSystem::NativesEnabledScope::~NativesEnabledScope() {
   module_system_->natives_enabled_--;
   CHECK_GE(module_system_->natives_enabled_, 0);
 }
 
-// static
-bool ModuleSystem::IsPresentInCurrentContext() {
-  // XXX(kalman): Not sure if this is safe. Investigate.
-  v8::Handle<v8::Object> global(v8::Context::GetCurrent()->Global());
-  if (global.IsEmpty())
-    return false;
-  v8::Handle<v8::Value> module_system =
-      global->GetHiddenValue(v8::String::New(kModuleSystem));
-  return !module_system.IsEmpty() && !module_system->IsUndefined();
-}
-
 void ModuleSystem::HandleException(const v8::TryCatch& try_catch) {
   DumpException(try_catch);
   if (exception_handler_.get())
     exception_handler_->HandleUncaughtException();
 }
 
 // static
 std::string ModuleSystem::CreateExceptionString(const v8::TryCatch& try_catch) {
   v8::Handle<v8::Message> message(try_catch.Message());
   if (message.IsEmpty()) {
@@ skipping 39 matching lines @@
 }
 
 v8::Handle<v8::Value> ModuleSystem::RequireForJs(const v8::Arguments& args) {
   v8::HandleScope handle_scope;
   v8::Handle<v8::String> module_name = args[0]->ToString();
   return handle_scope.Close(RequireForJsInner(module_name));
 }
 
 v8::Handle<v8::Value> ModuleSystem::RequireForJsInner(
     v8::Handle<v8::String> module_name) {
-  CHECK(is_valid_);
   v8::HandleScope handle_scope;
   v8::Handle<v8::Object> global(v8_context()->Global());
   v8::Handle<v8::Object> modules(v8::Handle<v8::Object>::Cast(
       global->GetHiddenValue(v8::String::New(kModulesField))));
   v8::Handle<v8::Value> exports(modules->Get(module_name));
   if (!exports->IsUndefined())
     return handle_scope.Close(exports);
 
   v8::Handle<v8::Value> source(GetSource(module_name));
   if (source->IsUndefined())
@@ skipping 95 matching lines @@
 // static
 v8::Handle<v8::Value> ModuleSystem::LazyFieldGetter(
     v8::Local<v8::String> property, const v8::AccessorInfo& info) {
   return LazyFieldGetterInner(property, info, &ModuleSystem::Require);
 }
 
 // static
 v8::Handle<v8::Value> ModuleSystem::LazyFieldGetterInner(
     v8::Local<v8::String> property,
     const v8::AccessorInfo& info,
-    GetModuleFunc get_module) {
+    RequireFn require_fn) {
   CHECK(!info.Data().IsEmpty());
   CHECK(info.Data()->IsObject());
   v8::HandleScope handle_scope;
   v8::Handle<v8::Object> parameters = v8::Handle<v8::Object>::Cast(info.Data());
   v8::Handle<v8::Object> global(parameters->CreationContext()->Global());
   v8::Handle<v8::Value> module_system_value =
       global->GetHiddenValue(v8::String::New(kModuleSystem));
   if (module_system_value.IsEmpty() || module_system_value->IsUndefined()) {
     // ModuleSystem has been deleted.
     return v8::Undefined();
   }
   ModuleSystem* module_system = static_cast<ModuleSystem*>(
       v8::Handle<v8::External>::Cast(module_system_value)->Value());
 
   std::string name = *v8::String::AsciiValue(
       parameters->Get(v8::String::New(kModuleName))->ToString());
 
-  // HACK(kalman): Switch to the context of the owner module system while
-  // lazily requiring modules.
-  //
-  // It seems to be a common incorrect assumption throughout code that the
-  // current context is the owner context. This makes that assumption true for
-  // at least the period where the JavaScript is first evaluated, which is when
-  // things are most likely to go wrong.
-  v8::Context::Scope context_scope(parameters->CreationContext());
-
   NativesEnabledScope natives_enabled_scope(module_system);
-
   v8::TryCatch try_catch;
   v8::Handle<v8::Object> module = v8::Handle<v8::Object>::Cast(
-      (module_system->*get_module)(name));
+      (module_system->*require_fn)(name));
   if (try_catch.HasCaught()) {
     module_system->HandleException(try_catch);
     return handle_scope.Close(v8::Handle<v8::Value>());
   }
 
   if (module.IsEmpty())
     return handle_scope.Close(v8::Handle<v8::Value>());
 
   v8::Handle<v8::String> field =
       parameters->Get(v8::String::New(kModuleField))->ToString();
 
+  // http://crbug.com/179741.
+  std::string field_name = *v8::String::AsciiValue(field);
+  char stack_debug[64];

[Matt Perry, 2013/03/05 21:51:38]

you might need to use base::Alias or whatever to make this available in crash
dumps.

[not at google - send to devlin, 2013/03/05 22:05:38]

Done.

+  base::snprintf(stack_debug, arraysize(stack_debug),
+                 "%s.%s", name.c_str(), field_name.c_str());
+
   v8::Local<v8::Value> new_field = module->Get(field);
   v8::Handle<v8::Object> object = info.This();
   // Delete the getter and set this field to |new_field| so the same object is
   // returned every time a certain API is accessed.
+  // CHECK is for http://crbug.com/179741.
+  CHECK(!new_field.IsEmpty()) << "Empty require " << name << "." << field_name;
   if (!new_field->IsUndefined()) {
     object->Delete(property);
     object->Set(property, new_field);
   }
   return handle_scope.Close(new_field);
 }
 
 void ModuleSystem::SetLazyField(v8::Handle<v8::Object> object,
                                 const std::string& field,
                                 const std::string& module_name,
@@ skipping 81 matching lines @@
   v8::Handle<v8::String> right = v8::String::New("\n})");
   return handle_scope.Close(
       v8::String::Concat(left, v8::String::Concat(source, right)));
 }
 
 v8::Handle<v8::Value> ModuleSystem::ThrowException(const std::string& message) {
   return v8::ThrowException(v8::String::New(message.c_str()));
 }
 
 }  // extensions