Revert trunk to bleeding_edge at r12484

test/cctest/test-api.cc

Index: test/cctest/test-api.cc
diff --git a/test/cctest/test-api.cc b/test/cctest/test-api.cc
index 067d134b18650b44a56b5ddcd2338477da7ea802..f7d8d807698a80565d3da0d5863e8b372240431c 100644
--- a/test/cctest/test-api.cc
+++ b/test/cctest/test-api.cc
@@ -404,10 +404,6 @@ THREADED_TEST(ScriptUsingStringResource) {
     CHECK(source->IsExternal());
     CHECK_EQ(resource,
              static_cast<TestResource*>(source->GetExternalStringResource()));
-    String::Encoding encoding = String::UNKNOWN_ENCODING;
-    CHECK_EQ(static_cast<const String::ExternalStringResourceBase*>(resource),
-             source->GetExternalStringResourceBase(&encoding));
-    CHECK_EQ(String::TWO_BYTE_ENCODING, encoding);
     HEAP->CollectAllGarbage(i::Heap::kNoGCFlags);
     CHECK_EQ(0, dispose_count);
   }
@@ -423,16 +419,9 @@ THREADED_TEST(ScriptUsingAsciiStringResource) {
   {
     v8::HandleScope scope;
     LocalContext env;
-    TestAsciiResource* resource = new TestAsciiResource(i::StrDup(c_source),
-                                                        &dispose_count);
-    Local<String> source = String::NewExternal(resource);
-    CHECK(source->IsExternalAscii());
-    CHECK_EQ(static_cast<const String::ExternalStringResourceBase*>(resource),
-             source->GetExternalAsciiStringResource());
-    String::Encoding encoding = String::UNKNOWN_ENCODING;
-    CHECK_EQ(static_cast<const String::ExternalStringResourceBase*>(resource),
-             source->GetExternalStringResourceBase(&encoding));
-    CHECK_EQ(String::ASCII_ENCODING, encoding);
+    Local<String> source =
+        String::NewExternal(new TestAsciiResource(i::StrDup(c_source),
+                                                  &dispose_count));
     Local<Script> script = Script::Compile(source);
     Local<Value> value = script->Run();
     CHECK(value->IsNumber());
@@ -456,11 +445,6 @@ THREADED_TEST(ScriptMakingExternalString) {
     // Trigger GCs so that the newly allocated string moves to old gen.
     HEAP->CollectGarbage(i::NEW_SPACE);  // in survivor space now
     HEAP->CollectGarbage(i::NEW_SPACE);  // in old gen now
-    CHECK_EQ(source->IsExternal(), false);
-    CHECK_EQ(source->IsExternalAscii(), false);
-    String::Encoding encoding = String::UNKNOWN_ENCODING;
-    CHECK_EQ(NULL, source->GetExternalStringResourceBase(&encoding));
-    CHECK_EQ(String::ASCII_ENCODING, encoding);
     bool success = source->MakeExternal(new TestResource(two_byte_source,
                                                          &dispose_count));
     CHECK(success);
@@ -4687,18 +4671,6 @@ THREADED_TEST(SimpleExtensions) {
 }
 
 
-THREADED_TEST(NullExtensions) {
-  v8::HandleScope handle_scope;
-  v8::RegisterExtension(new Extension("nulltest", NULL));
-  const char* extension_names[] = { "nulltest" };
-  v8::ExtensionConfiguration extensions(1, extension_names);
-  v8::Handle<Context> context = Context::New(&extensions);
-  Context::Scope lock(context);
-  v8::Handle<Value> result = Script::Compile(v8_str("1+3"))->Run();
-  CHECK_EQ(result, v8::Integer::New(4));
-}
-
-
 static const char* kEmbeddedExtensionSource =
     "function Ret54321(){return 54321;}~~@@$"
     "$%% THIS IS A SERIES OF NON-NULL-TERMINATED STRINGS.";
@@ -14039,41 +14011,6 @@ THREADED_TEST(ExternalArrayInfo) {
 }
 
 
-void ExternalArrayLimitTestHelper(v8::ExternalArrayType array_type, int size) {
-  v8::Handle<v8::Object> obj = v8::Object::New();
-  v8::V8::SetFatalErrorHandler(StoringErrorCallback);
-  last_location = last_message = NULL;
-  obj->SetIndexedPropertiesToExternalArrayData(NULL, array_type, size);
-  CHECK(!obj->HasIndexedPropertiesInExternalArrayData());
-  CHECK_NE(NULL, last_location);
-  CHECK_NE(NULL, last_message);
-}
-
-
-TEST(ExternalArrayLimits) {
-  v8::HandleScope scope;
-  LocalContext context;
-  ExternalArrayLimitTestHelper(v8::kExternalByteArray, 0x40000000);
-  ExternalArrayLimitTestHelper(v8::kExternalByteArray, 0xffffffff);
-  ExternalArrayLimitTestHelper(v8::kExternalUnsignedByteArray, 0x40000000);
-  ExternalArrayLimitTestHelper(v8::kExternalUnsignedByteArray, 0xffffffff);
-  ExternalArrayLimitTestHelper(v8::kExternalShortArray, 0x40000000);
-  ExternalArrayLimitTestHelper(v8::kExternalShortArray, 0xffffffff);
-  ExternalArrayLimitTestHelper(v8::kExternalUnsignedShortArray, 0x40000000);
-  ExternalArrayLimitTestHelper(v8::kExternalUnsignedShortArray, 0xffffffff);
-  ExternalArrayLimitTestHelper(v8::kExternalIntArray, 0x40000000);
-  ExternalArrayLimitTestHelper(v8::kExternalIntArray, 0xffffffff);
-  ExternalArrayLimitTestHelper(v8::kExternalUnsignedIntArray, 0x40000000);
-  ExternalArrayLimitTestHelper(v8::kExternalUnsignedIntArray, 0xffffffff);
-  ExternalArrayLimitTestHelper(v8::kExternalFloatArray, 0x40000000);
-  ExternalArrayLimitTestHelper(v8::kExternalFloatArray, 0xffffffff);
-  ExternalArrayLimitTestHelper(v8::kExternalDoubleArray, 0x40000000);
-  ExternalArrayLimitTestHelper(v8::kExternalDoubleArray, 0xffffffff);
-  ExternalArrayLimitTestHelper(v8::kExternalPixelArray, 0x40000000);
-  ExternalArrayLimitTestHelper(v8::kExternalPixelArray, 0xffffffff);
-}
-
-
 THREADED_TEST(ScriptContextDependence) {
   v8::HandleScope scope;
   LocalContext c1;
@@ -14452,89 +14389,6 @@ TEST(SourceURLInStackTrace) {
 }
 
 
-v8::Handle<Value> AnalyzeStackOfInlineScriptWithSourceURL(
-    const v8::Arguments& args) {
-  v8::HandleScope scope;
-  v8::Handle<v8::StackTrace> stackTrace =
-      v8::StackTrace::CurrentStackTrace(10, v8::StackTrace::kDetailed);
-  CHECK_EQ(4, stackTrace->GetFrameCount());
-  v8::Handle<v8::String> url = v8_str("url");
-  for (int i = 0; i < 3; i++) {
-    v8::Handle<v8::String> name =
-        stackTrace->GetFrame(i)->GetScriptNameOrSourceURL();
-    CHECK(!name.IsEmpty());
-    CHECK_EQ(url, name);
-  }
-  return v8::Undefined();
-}
-
-
-TEST(InlineScriptWithSourceURLInStackTrace) {
-  v8::HandleScope scope;
-  Local<ObjectTemplate> templ = ObjectTemplate::New();
-  templ->Set(v8_str("AnalyzeStackOfInlineScriptWithSourceURL"),
-             v8::FunctionTemplate::New(
-                 AnalyzeStackOfInlineScriptWithSourceURL));
-  LocalContext context(0, templ);
-
-  const char *source =
-    "function outer() {\n"
-    "function bar() {\n"
-    "  AnalyzeStackOfInlineScriptWithSourceURL();\n"
-    "}\n"
-    "function foo() {\n"
-    "\n"
-    "  bar();\n"
-    "}\n"
-    "foo();\n"
-    "}\n"
-    "outer()\n"
-    "//@ sourceURL=source_url";
-  CHECK(CompileRunWithOrigin(source, "url", 0, 1)->IsUndefined());
-}
-
-
-v8::Handle<Value> AnalyzeStackOfDynamicScriptWithSourceURL(
-    const v8::Arguments& args) {
-  v8::HandleScope scope;
-  v8::Handle<v8::StackTrace> stackTrace =
-      v8::StackTrace::CurrentStackTrace(10, v8::StackTrace::kDetailed);
-  CHECK_EQ(4, stackTrace->GetFrameCount());
-  v8::Handle<v8::String> url = v8_str("source_url");
-  for (int i = 0; i < 3; i++) {
-    v8::Handle<v8::String> name =
-        stackTrace->GetFrame(i)->GetScriptNameOrSourceURL();
-    CHECK(!name.IsEmpty());
-    CHECK_EQ(url, name);
-  }
-  return v8::Undefined();
-}
-
-
-TEST(DynamicWithSourceURLInStackTrace) {
-  v8::HandleScope scope;
-  Local<ObjectTemplate> templ = ObjectTemplate::New();
-  templ->Set(v8_str("AnalyzeStackOfDynamicScriptWithSourceURL"),
-             v8::FunctionTemplate::New(
-                 AnalyzeStackOfDynamicScriptWithSourceURL));
-  LocalContext context(0, templ);
-
-  const char *source =
-    "function outer() {\n"
-    "function bar() {\n"
-    "  AnalyzeStackOfDynamicScriptWithSourceURL();\n"
-    "}\n"
-    "function foo() {\n"
-    "\n"
-    "  bar();\n"
-    "}\n"
-    "foo();\n"
-    "}\n"
-    "outer()\n"
-    "//@ sourceURL=source_url";
-  CHECK(CompileRunWithOrigin(source, "url", 0, 0)->IsUndefined());
-}
-
 static void CreateGarbageInOldSpace() {
   v8::HandleScope scope;
   i::AlwaysAllocateScope always_allocate;
@@ -16607,24 +16461,6 @@ THREADED_TEST(AllowCodeGenFromStrings) {
 }
 
 
-TEST(SetErrorMessageForCodeGenFromStrings) {
-  v8::HandleScope scope;
-  LocalContext context;
-  TryCatch try_catch;
-
-  Handle<String> message = v8_str("Message") ;
-  Handle<String> expected_message = v8_str("Uncaught EvalError: Message");
-  V8::SetAllowCodeGenerationFromStringsCallback(&CodeGenerationDisallowed);
-  context->AllowCodeGenerationFromStrings(false);
-  context->SetErrorMessageForCodeGenerationFromStrings(message);
-  Handle<Value> result = CompileRun("eval('42')");
-  CHECK(result.IsEmpty());
-  CHECK(try_catch.HasCaught());
-  Handle<String> actual_message = try_catch.Message()->Get();
-  CHECK(expected_message->Equals(actual_message));
-}
-
-
 static v8::Handle<Value> NonObjectThis(const v8::Arguments& args) {
   return v8::Undefined();
 }
@@ -17552,16 +17388,6 @@ THREADED_TEST(Regress137496) {
 }
 
 
-THREADED_TEST(Regress149912) {
-  v8::HandleScope scope;
-  LocalContext context;
-  Handle<FunctionTemplate> templ = FunctionTemplate::New();
-  AddInterceptor(templ, EmptyInterceptorGetter, EmptyInterceptorSetter);
-  context->Global()->Set(v8_str("Bug"), templ->GetFunction());
-  CompileRun("Number.prototype.__proto__ = new Bug; var x = 0; x.foo();");
-}
-
-
 #ifndef WIN32
 class ThreadInterruptTest {
  public: