Revert preparser duplicate detection.

src/utils.h

 // Copyright 2011 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 478 matching lines @@
  * There is no guarantee that the backing store is contiguous (and, as a
  * consequence, no guarantees that consecutively added elements are adjacent
  * in memory). The collector may move elements unless it has guaranteed not
  * to.
  */
 template <typename T, int growth_factor = 2, int max_growth = 1 * MB>
 class Collector {
  public:
   explicit Collector(int initial_capacity = kMinCapacity)
       : index_(0), size_(0) {
+    if (initial_capacity < kMinCapacity) {
+      initial_capacity = kMinCapacity;
+    }
     current_chunk_ = Vector<T>::New(initial_capacity);
   }
 
   virtual ~Collector() {
     // Free backing store (in reverse allocation order).
     current_chunk_.Dispose();
     for (int i = chunks_.length() - 1; i >= 0; i--) {
       chunks_.at(i).Dispose();
     }
   }
@@ skipping 81 matching lines @@
  protected:
   static const int kMinCapacity = 16;
   List<Vector<T> > chunks_;
   Vector<T> current_chunk_;  // Block of memory currently being written into.
   int index_;  // Current index in current chunk.
   int size_;  // Total number of elements in collector.
 
   // Creates a new current chunk, and stores the old chunk in the chunks_ list.
   void Grow(int min_capacity) {
     ASSERT(growth_factor > 1);
-    int new_capacity;
-    int current_length = current_chunk_.length();
-    if (current_length < kMinCapacity) {
-      // The collector started out as empty.
-      new_capacity = min_capacity * growth_factor;
-      if (new_capacity < kMinCapacity) new_capacity = kMinCapacity;
-    } else {
-      int growth = current_length * (growth_factor - 1);
-      if (growth > max_growth) {
-        growth = max_growth;
-      }
-      new_capacity = current_length + growth;
-      if (new_capacity < min_capacity) {
-        new_capacity = min_capacity + growth;
-      }
+    int growth = current_chunk_.length() * (growth_factor - 1);
+    if (growth > max_growth) {
+      growth = max_growth;
+    }
+    int new_capacity = current_chunk_.length() + growth;
+    if (new_capacity < min_capacity) {
+      new_capacity = min_capacity + growth;
     }
     Vector<T> new_chunk = Vector<T>::New(new_capacity);
     int new_index = PrepareGrow(new_chunk);
     if (index_ > 0) {
       chunks_.Add(current_chunk_.SubVector(0, index_));
     } else {
       // Can happen if the call to PrepareGrow moves everything into
       // the new chunk.
       current_chunk_.Dispose();
     }
@@ skipping 261 matching lines @@
   int position_;
 
   bool is_finalized() const { return position_ < 0; }
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(SimpleStringBuilder);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_UTILS_H_