Rename SeqAsciiString

src/json-stringifier.h

 // 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 201 matching lines @@
     "x\0      y\0      z\0      {\0      "
     "|\0      }\0      ~\0      \177\0      ";
 
 
 BasicJsonStringifier::BasicJsonStringifier(Isolate* isolate)
     : isolate_(isolate), current_index_(0), is_ascii_(true) {
   factory_ = isolate_->factory();
   accumulator_store_ = Handle<JSValue>::cast(
                            factory_->ToObject(factory_->empty_string()));
   part_length_ = kInitialPartLength;
-  current_part_ = factory_->NewRawAsciiString(kInitialPartLength);
+  current_part_ = factory_->NewRawOneByteString(kInitialPartLength);
   tojson_symbol_ = factory_->LookupAsciiSymbol("toJSON");
   stack_ = factory_->NewJSArray(8);
 }
 
 
 MaybeObject* BasicJsonStringifier::Stringify(Handle<Object> object) {
   switch (SerializeObject(object)) {
     case UNCHANGED:
       return isolate_->heap()->undefined_value();
     case SUCCESS:
       ShrinkCurrentPart();
       return *factory_->NewConsString(accumulator(), current_part_);
     case CIRCULAR:
       return isolate_->Throw(*factory_->NewTypeError(
                  "circular_structure", HandleVector<Object>(NULL, 0)));
     case STACK_OVERFLOW:
       return isolate_->StackOverflow();
     default:
       return Failure::Exception();
   }
 }
 
 
 template <bool is_ascii, typename Char>
 void BasicJsonStringifier::Append_(Char c) {
   if (is_ascii) {
-    SeqAsciiString::cast(*current_part_)->SeqAsciiStringSet(
+    SeqOneByteString::cast(*current_part_)->SeqOneByteStringSet(
         current_index_++, c);
   } else {
     SeqTwoByteString::cast(*current_part_)->SeqTwoByteStringSet(
         current_index_++, c);
   }
   if (current_index_ == part_length_) Extend();
 }
 
 
 template <bool is_ascii, typename Char>
@@ skipping 369 matching lines @@
 
 void BasicJsonStringifier::ShrinkCurrentPart() {
   ASSERT(current_index_ < part_length_);
   if (current_index_ == 0) {
     current_part_ = factory_->empty_string();
     return;
   }
 
   int string_size, allocated_string_size;
   if (is_ascii_) {
-    allocated_string_size = SeqAsciiString::SizeFor(part_length_);
-    string_size = SeqAsciiString::SizeFor(current_index_);
+    allocated_string_size = SeqOneByteString::SizeFor(part_length_);
+    string_size = SeqOneByteString::SizeFor(current_index_);
   } else {
     allocated_string_size = SeqTwoByteString::SizeFor(part_length_);
     string_size = SeqTwoByteString::SizeFor(current_index_);
   }
 
   int delta = allocated_string_size - string_size;
   current_part_->set_length(current_index_);
 
   // String sizes are pointer size aligned, so that we can use filler objects
   // that are a multiple of pointer size.
   Address end_of_string = current_part_->address() + string_size;
   isolate_->heap()->CreateFillerObjectAt(end_of_string, delta);
   if (Marking::IsBlack(Marking::MarkBitFrom(*current_part_))) {
     MemoryChunk::IncrementLiveBytesFromMutator(
         current_part_->address(), -delta);
   }
 }
 
 
 void BasicJsonStringifier::Extend() {
   set_accumulator(factory_->NewConsString(accumulator(), current_part_));
   if (part_length_ <= kMaxPartLength / kPartLengthGrowthFactor) {
     part_length_ *= kPartLengthGrowthFactor;
   }
   if (is_ascii_) {
-    current_part_ = factory_->NewRawAsciiString(part_length_);
+    current_part_ = factory_->NewRawOneByteString(part_length_);
   } else {
     current_part_ = factory_->NewRawTwoByteString(part_length_);
   }
   current_index_ = 0;
 }
 
 
 void BasicJsonStringifier::ChangeEncoding() {
   ShrinkCurrentPart();
   set_accumulator(factory_->NewConsString(accumulator(), current_part_));
@@ skipping 35 matching lines @@
   Append_<is_ascii, char>('"');
   // We make a rough estimate to find out if the current string can be
   // serialized without allocating a new string part. The worst case length of
   // an escaped character is 6.  Shifting the remainin string length right by 3
   // is a more pessimistic estimate, but faster to calculate.
 
   if (((part_length_ - current_index_) >> 3) > length) {
     if (is_ascii) {
       SerializeStringUnchecked_(
           vector.start(),
-          SeqAsciiString::cast(*current_part_)->GetChars(),
+          SeqOneByteString::cast(*current_part_)->GetChars(),
           length);
     } else {
       SerializeStringUnchecked_(
           vector.start(),
           SeqTwoByteString::cast(*current_part_)->GetChars(),
           length);
     }
   } else {
     String* string_location = *string;
     for (int i = 0; i < length; i++) {
@@ skipping 59 matching lines @@
       SerializeString_<false, char>(flat.ToAsciiVector(), object);
     } else {
       SerializeString_<false, uc16>(flat.ToUC16Vector(), object);
     }
   }
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_JSON_STRINGIFIER_H_