Don't throw exceptions when v8 objects/contexts are missing, and catch

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/debug/alias.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 "chrome/renderer/extensions/console.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";
 
@@ skipping 114 matching lines @@
 v8::Handle<v8::Value> ModuleSystem::RequireForJsInner(
     v8::Handle<v8::String> module_name) {
   v8::HandleScope handle_scope;
   v8::Handle<v8::Object> global(v8_context()->Global());
 
   // The module system might have been deleted. This can happen if a different
   // context keeps a reference to us, but our frame is destroyed (e.g.
   // background page keeps reference to chrome object in a closed popup).
   v8::Handle<v8::Value> modules_value =
       global->GetHiddenValue(v8::String::New(kModulesField));
-  if (modules_value.IsEmpty() || modules_value->IsUndefined())
-    return ThrowException("Extension view no longer exists");
+  if (modules_value.IsEmpty() || modules_value->IsUndefined()) {
+    console::Error(v8::Context::GetCalling(),
+                   "Extension view no longer exists");
+  }
 
   v8::Handle<v8::Object> modules(v8::Handle<v8::Object>::Cast(modules_value));
   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));
+  std::string module_name_str = *v8::String::AsciiValue(module_name);
+  v8::Handle<v8::Value> source(GetSource(module_name_str));
   if (source->IsUndefined())
     return handle_scope.Close(v8::Undefined());
   v8::Handle<v8::String> wrapped_source(WrapSource(
       v8::Handle<v8::String>::Cast(source)));
   v8::Handle<v8::Function> func =
       v8::Handle<v8::Function>::Cast(RunString(wrapped_source, module_name));
-  if (func.IsEmpty()) {
-    return ThrowException(std::string(*v8::String::AsciiValue(module_name)) +
-        ": Bad source");
-  }
+  CHECK(!func.IsEmpty()) << "Bad source code for " << module_name_str;
 
   exports = v8::Object::New();
   v8::Handle<v8::Object> natives(NewInstance());
   v8::Handle<v8::Value> args[] = {
     natives->Get(v8::String::NewSymbol("require")),
     natives->Get(v8::String::NewSymbol("requireNative")),
     exports,
   };
   {
     WebKit::WebScopedMicrotaskSuppression suppression;
@@ skipping 188 matching lines @@
     return handle_scope.Close(result);
   }
 
   result = script->Run();
   if (try_catch.HasCaught())
     HandleException(try_catch);
 
   return handle_scope.Close(result);
 }
 
-v8::Handle<v8::Value> ModuleSystem::GetSource(
-    v8::Handle<v8::String> source_name) {
+v8::Handle<v8::Value> ModuleSystem::GetSource(const std::string& module_name) {
   v8::HandleScope handle_scope;
-  std::string module_name = *v8::String::AsciiValue(source_name);
   if (!source_map_->Contains(module_name))
     return v8::Undefined();
   return handle_scope.Close(source_map_->GetSource(module_name));
 }
 
 v8::Handle<v8::Value> ModuleSystem::RequireNative(const v8::Arguments& args) {
   CHECK_EQ(1, args.Length());
   std::string native_name = *v8::String::AsciiValue(args[0]->ToString());
   return RequireNativeFromString(native_name);
 }
 
 v8::Handle<v8::Value> ModuleSystem::RequireNativeFromString(
     const std::string& native_name) {
   if (natives_enabled_ == 0)
-    return ThrowException("Natives disabled");
+    return v8::ThrowException(v8::String::New("Natives disabled"));
   if (overridden_native_handlers_.count(native_name) > 0u)
     return RequireForJsInner(v8::String::New(native_name.c_str()));
   NativeHandlerMap::iterator i = native_handler_map_.find(native_name);
   if (i == native_handler_map_.end())
     return v8::Undefined();
   return i->second->NewInstance();
 }
 
 v8::Handle<v8::String> ModuleSystem::WrapSource(v8::Handle<v8::String> source) {
   v8::HandleScope handle_scope;
   v8::Handle<v8::String> left = v8::String::New(
       "(function(require, requireNative, exports) {'use strict';");
   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