Revert 3245 and 3246 because they cause valgrind failures.

src/scanner.cc

 // Copyright 2006-2008 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 31 matching lines @@
 unibrow::Predicate<unibrow::LineTerminator, 128> Scanner::kIsLineTerminator;
 unibrow::Predicate<unibrow::WhiteSpace, 128> Scanner::kIsWhiteSpace;
 
 
 StaticResource<Scanner::Utf8Decoder> Scanner::utf8_decoder_;
 
 
 // ----------------------------------------------------------------------------
 // UTF8Buffer
 
-UTF8Buffer::UTF8Buffer() : data_(NULL), limit_(NULL) { }
+UTF8Buffer::UTF8Buffer() {
+  static const int kInitialCapacity = 1 * KB;
+  data_ = NewArray<char>(kInitialCapacity);
+  limit_ = ComputeLimit(data_, kInitialCapacity);
+  Reset();
+  ASSERT(Capacity() == kInitialCapacity && pos() == 0);
+}
 
 
 UTF8Buffer::~UTF8Buffer() {
   DeleteArray(data_);
 }
 
 
 void UTF8Buffer::AddCharSlow(uc32 c) {
   static const int kCapacityGrowthLimit = 1 * MB;
   if (cursor_ > limit_) {
     int old_capacity = Capacity();
     int old_position = pos();
     int new_capacity =
-        Min(old_capacity * 3, old_capacity + kCapacityGrowthLimit);
+        Min(old_capacity * 2, old_capacity + kCapacityGrowthLimit);
     char* new_data = NewArray<char>(new_capacity);
     memcpy(new_data, data_, old_position);
     DeleteArray(data_);
     data_ = new_data;
     cursor_ = new_data + old_position;
     limit_ = ComputeLimit(new_data, new_capacity);
     ASSERT(Capacity() == new_capacity && pos() == old_position);
   }
   if (static_cast<unsigned>(c) <= unibrow::Utf8::kMaxOneByteChar) {
     *cursor_++ = c;  // Common case: 7-bit ASCII.
@@ skipping 256 matching lines @@
     two_byte_string_buffer_.Initialize(
         Handle<ExternalTwoByteString>::cast(source));
     source_ = &two_byte_string_buffer_;
   } else {
     char_stream_buffer_.Initialize(source, stream);
     source_ = &char_stream_buffer_;
   }
 
   position_ = position;
 
+  // Reset literals buffer
+  literals_.Reset();
+
   // Set c0_ (one character ahead)
   ASSERT(kCharacterLookaheadBufferSize == 1);
   Advance();
 
   // Skip initial whitespace allowing HTML comment ends just like
   // after a newline and scan first token.
   has_line_terminator_before_next_ = true;
   SkipWhiteSpace();
   Scan();
 }
 
 
 Handle<String> Scanner::SubString(int start, int end) {
   return source_->SubString(start - position_, end - position_);
 }
 
 
 Token::Value Scanner::Next() {
   // BUG 1215673: Find a thread safe way to set a stack limit in
   // pre-parse mode. Otherwise, we cannot safely pre-parse from other
   // threads.
   current_ = next_;
   // Check for stack-overflow before returning any tokens.
   StackLimitCheck check;
   if (check.HasOverflowed()) {
     stack_overflow_ = true;
     next_.token = Token::ILLEGAL;
-    next_.literal_buffer = NULL;
   } else {
     Scan();
   }
   return current_.token;
 }
 
 
 void Scanner::StartLiteral() {
-  // Use the first buffer unless it's currently in use by the current_ token.
-  // In most cases we won't have two literals/identifiers in a row, so
-  // the second buffer won't be used very often and is unlikely to grow much.
-  UTF8Buffer* free_buffer =
-      (current_.literal_buffer != &literal_buffer_1_) ? &literal_buffer_1_
-                                                      : &literal_buffer_2_;
-  next_.literal_buffer = free_buffer;
-  free_buffer->Reset();
+  next_.literal_pos = literals_.pos();
 }
 
 
 void Scanner::AddChar(uc32 c) {
-  next_.literal_buffer->AddChar(c);
+  literals_.AddChar(c);
 }
 
 
 void Scanner::TerminateLiteral() {
+  next_.literal_end = literals_.pos();
   AddChar(0);
 }
 
 
 void Scanner::AddCharAdvance() {
   AddChar(c0_);
   Advance();
 }
 
 
@@ skipping 681 matching lines @@
     }
     AddCharAdvance();
   }
   TerminateLiteral();
 
   next_.location.end_pos = source_pos() - 1;
   return true;
 }
 
 } }  // namespace v8::internal