Introduce v8::Exception::GetMessage to find location of an error object.

test/cctest/test-api.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 8529 matching lines @@
   v8::Handle<String> foo = v8_str("foo");
   v8::Handle<String> message = v8_str("message");
   v8::Handle<Value> error = v8::Exception::Error(foo);
   CHECK(error->IsObject());
   CHECK(error.As<v8::Object>()->Get(message)->Equals(foo));
   info.GetIsolate()->ThrowException(error);
   info.GetReturnValue().SetUndefined();
 }
 
 
-THREADED_TEST(ExceptionGetStackTrace) {
+THREADED_TEST(ExceptionGetMessage) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
 
   v8::V8::SetCaptureStackTraceForUncaughtExceptions(true);
 
   Local<v8::FunctionTemplate> fun =
       v8::FunctionTemplate::New(context->GetIsolate(), ThrowV8Exception);
   v8::Local<v8::Object> global = context->Global();
   global->Set(v8_str("throwV8Exception"), fun->GetFunction());
 
   TryCatch try_catch;
-  CompileRun("function f1() { throwV8Exception(); }; f1();");
+  CompileRun(
+      "function f1() {\n"
+      "  throwV8Exception();\n"
+      "};\n"
+      "f1();");
   CHECK(try_catch.HasCaught());
 
   v8::Handle<v8::Value> error = try_catch.Exception();
-  v8::Handle<String> foo = v8_str("foo");
-  v8::Handle<String> message = v8_str("message");
+  v8::Handle<String> foo_str = v8_str("foo");
+  v8::Handle<String> message_str = v8_str("message");
   CHECK(error->IsObject());
-  CHECK(error.As<v8::Object>()->Get(message)->Equals(foo));
+  CHECK(error.As<v8::Object>()->Get(message_str)->Equals(foo_str));
 
-  v8::Handle<v8::StackTrace> stackTrace = v8::Exception::GetStackTrace(error);
+  v8::Handle<v8::Message> message = v8::Exception::GetMessage(error);
+  CHECK(!message.IsEmpty());
+  CHECK_EQ(2, message->GetLineNumber());
+  CHECK_EQ(2, message->GetStartColumn());
+
+  v8::Handle<v8::StackTrace> stackTrace = message->GetStackTrace();
   CHECK(!stackTrace.IsEmpty());
   CHECK_EQ(2, stackTrace->GetFrameCount());
 
   v8::V8::SetCaptureStackTraceForUncaughtExceptions(false);
 }
 
 
 static void YGetter(Local<String> name,
                     const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
@@ skipping 9284 matching lines @@
 int promise_reject_counter = 0;
 int promise_revoke_counter = 0;
 int promise_reject_line_number = -1;
 int promise_reject_frame_count = -1;
 
 void PromiseRejectCallback(v8::PromiseRejectMessage message) {
   if (message.GetEvent() == v8::kPromiseRejectWithNoHandler) {
     promise_reject_counter++;
     CcTest::global()->Set(v8_str("rejected"), message.GetPromise());
     CcTest::global()->Set(v8_str("value"), message.GetValue());
-    v8::Handle<v8::StackTrace> stack_trace = message.GetStackTrace();
+    v8::Handle<v8::StackTrace> stack_trace =
+        v8::Exception::GetMessage(message.GetValue())->GetStackTrace();
     if (!stack_trace.IsEmpty()) {
       promise_reject_frame_count = stack_trace->GetFrameCount();
       if (promise_reject_frame_count > 0) {
         CHECK(stack_trace->GetFrame(0)->GetScriptName()->Equals(v8_str("pro")));
         promise_reject_line_number = stack_trace->GetFrame(0)->GetLineNumber();
       } else {
         promise_reject_line_number = -1;
       }
     }
   } else {
     promise_revoke_counter++;
     CcTest::global()->Set(v8_str("revoked"), message.GetPromise());
     CHECK(message.GetValue().IsEmpty());
-    CHECK(message.GetStackTrace().IsEmpty());
   }
 }
 
 
 v8::Handle<v8::Promise> GetPromise(const char* name) {
   return v8::Handle<v8::Promise>::Cast(CcTest::global()->Get(v8_str(name)));
 }
 
 
 v8::Handle<v8::Value> RejectValue() {
@@ skipping 6135 matching lines @@
   char chunk2[] =
       "XX\xec\x92\x81r = 13;\n"
       "  return foob\xec\x92\x81\xec\x92\x81r;\n"
       "}\n";
   chunk1[strlen(chunk1) - 1] = reference[0];
   chunk2[0] = reference[1];
   chunk2[1] = reference[2];
   const char* chunks[] = {chunk1, chunk2, "foo();", NULL};
   RunStreamingTest(chunks, v8::ScriptCompiler::StreamedSource::UTF8);
 }