Rename v8::Exception::GetMessage to CreateMessage.

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 8617 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(ExceptionGetMessage) {
+THREADED_TEST(ExceptionCreateMessage) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   v8::Handle<String> foo_str = v8_str("foo");
   v8::Handle<String> message_str = v8_str("message");
 
   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() {\n"
       "  throwV8Exception();\n"
       "};\n"
       "f1();");
   CHECK(try_catch.HasCaught());
 
   v8::Handle<v8::Value> error = try_catch.Exception();
   CHECK(error->IsObject());
   CHECK(error.As<v8::Object>()->Get(message_str)->Equals(foo_str));
 
-  v8::Handle<v8::Message> message = v8::Exception::GetMessage(error);
+  v8::Handle<v8::Message> message = v8::Exception::CreateMessage(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);
 
   // Now check message location when SetCaptureStackTraceForUncaughtExceptions
   // is false.
   try_catch.Reset();
 
   CompileRun(
       "function f2() {\n"
       "  return throwV8Exception();\n"
       "};\n"
       "f2();");
   CHECK(try_catch.HasCaught());
 
   error = try_catch.Exception();
   CHECK(error->IsObject());
   CHECK(error.As<v8::Object>()->Get(message_str)->Equals(foo_str));
 
-  message = v8::Exception::GetMessage(error);
+  message = v8::Exception::CreateMessage(error);
   CHECK(!message.IsEmpty());
   CHECK_EQ(2, message->GetLineNumber());
   CHECK_EQ(9, message->GetStartColumn());
 
   // Should be empty stack trace.
   stackTrace = message->GetStackTrace();
   CHECK(stackTrace.IsEmpty());
 }
 
 
@@ skipping 9315 matching lines @@
 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 =
-        v8::Exception::GetMessage(message.GetValue())->GetStackTrace();
+        v8::Exception::CreateMessage(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 {
@@ skipping 6159 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);
 }