Rename LookupSymbol calls to use Utf8 or OneByte in names.

src/factory.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 140 matching lines @@
 
 
 Handle<TypeFeedbackInfo> Factory::NewTypeFeedbackInfo() {
   CALL_HEAP_FUNCTION(isolate(),
                      isolate()->heap()->AllocateTypeFeedbackInfo(),
                      TypeFeedbackInfo);
 }
 
 
 // Symbols are created in the old generation (data space).
-Handle<String> Factory::LookupSymbol(Vector<const char> string) {
+Handle<String> Factory::LookupUtf8Symbol(Vector<const char> string) {
   CALL_HEAP_FUNCTION(isolate(),
-                     isolate()->heap()->LookupSymbol(string),
+                     isolate()->heap()->LookupUtf8Symbol(string),
                      String);
 }
 
 // Symbols are created in the old generation (data space).
 Handle<String> Factory::LookupSymbol(Handle<String> string) {
   CALL_HEAP_FUNCTION(isolate(),
                      isolate()->heap()->LookupSymbol(*string),
                      String);
 }
 
-Handle<String> Factory::LookupAsciiSymbol(Vector<const char> string) {
+Handle<String> Factory::LookupOneByteSymbol(Vector<const char> string) {
   CALL_HEAP_FUNCTION(isolate(),
-                     isolate()->heap()->LookupAsciiSymbol(string),
+                     isolate()->heap()->LookupOneByteSymbol(string),
                      String);
 }
 
 
-Handle<String> Factory::LookupAsciiSymbol(Handle<SeqOneByteString> string,
+Handle<String> Factory::LookupOneByteSymbol(Handle<SeqOneByteString> string,
                                           int from,
                                           int length) {
   CALL_HEAP_FUNCTION(isolate(),
-                     isolate()->heap()->LookupAsciiSymbol(string,
+                     isolate()->heap()->LookupOneByteSymbol(string,
                                                           from,
                                                           length),
                      String);
 }
 
 
 Handle<String> Factory::LookupTwoByteSymbol(Vector<const uc16> string) {
   CALL_HEAP_FUNCTION(isolate(),
                      isolate()->heap()->LookupTwoByteSymbol(string),
                      String);
@@ skipping 538 matching lines @@
     buffer[kBufferSize - 1] = '\0';
   }
   Handle<String> error_string = NewStringFromUtf8(CStrVector(buffer), TENURED);
   return error_string;
 }
 
 
 Handle<Object> Factory::NewError(const char* maker,
                                  const char* type,
                                  Handle<JSArray> args) {
-  Handle<String> make_str = LookupAsciiSymbol(maker);
+  Handle<String> make_str = LookupUtf8Symbol(maker);
   Handle<Object> fun_obj(
       isolate()->js_builtins_object()->GetPropertyNoExceptionThrown(*make_str));
   // If the builtins haven't been properly configured yet this error
   // constructor may not have been defined.  Bail out.
   if (!fun_obj->IsJSFunction()) {
     return EmergencyNewError(type, args);
   }
   Handle<JSFunction> fun = Handle<JSFunction>::cast(fun_obj);
-  Handle<Object> type_obj = LookupAsciiSymbol(type);
+  Handle<Object> type_obj = LookupUtf8Symbol(type);
   Handle<Object> argv[] = { type_obj, args };
 
   // Invoke the JavaScript factory method. If an exception is thrown while
   // running the factory method, use the exception as the result.
   bool caught_exception;
   Handle<Object> result = Execution::TryCall(fun,
                                              isolate()->js_builtins_object(),
                                              ARRAY_SIZE(argv),
                                              argv,
                                              &caught_exception);
   return result;
 }
 
 
 Handle<Object> Factory::NewError(Handle<String> message) {
   return NewError("$Error", message);
 }
 
 
 Handle<Object> Factory::NewError(const char* constructor,
                                  Handle<String> message) {
-  Handle<String> constr = LookupAsciiSymbol(constructor);
+  Handle<String> constr = LookupUtf8Symbol(constructor);
   Handle<JSFunction> fun = Handle<JSFunction>(
       JSFunction::cast(isolate()->js_builtins_object()->
                        GetPropertyNoExceptionThrown(*constr)));
   Handle<Object> argv[] = { message };
 
   // Invoke the JavaScript factory method. If an exception is thrown while
   // running the factory method, use the exception as the result.
   bool caught_exception;
   Handle<Object> result = Execution::TryCall(fun,
                                              isolate()->js_builtins_object(),
@@ skipping 657 matching lines @@
 
 
 Handle<Object> Factory::ToBoolean(bool value) {
   return Handle<Object>(value
                         ? isolate()->heap()->true_value()
                         : isolate()->heap()->false_value());
 }
 
 
 } }  // namespace v8::internal