Remove some unnecessary use of templates.

src/heap.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 4656 matching lines @@
     case SHORT_EXTERNAL_STRING_TYPE: return short_external_symbol_map();
     case SHORT_EXTERNAL_ASCII_STRING_TYPE:
       return short_external_ascii_symbol_map();
     case SHORT_EXTERNAL_STRING_WITH_ASCII_DATA_TYPE:
       return short_external_symbol_with_ascii_data_map();
     default: return NULL;  // No match found.
   }
 }
 
 
-template<typename T>
-class AllocateInternalSymbolHelper {
- public:
-  static void WriteOneByteData(T t, char* chars, int len);
-  static void WriteTwoByteData(T t, uint16_t* chars, int len);
- private:
-  DISALLOW_COPY_AND_ASSIGN(AllocateInternalSymbolHelper);
-};
+static inline void WriteOneByteData(Vector<const char> vector,
+                                    uint8_t* chars,
+                                    int len) {
+  // Only works for ascii.
+  ASSERT(vector.length() == len);
+  memcpy(chars, vector.start(), len);
+}
+
+static inline void WriteTwoByteData(Vector<const char> vector,
+                                    uint16_t* chars,
+                                    int len) {
+  const uint8_t* stream = reinterpret_cast<const uint8_t*>(vector.start());
+  unsigned stream_length = vector.length();
+  while (stream_length != 0) {
+    unsigned consumed = 0;
+    uint32_t c = unibrow::Utf8::ValueOf(stream, stream_length, &consumed);
+    ASSERT(c != unibrow::Utf8::kBadChar);
+    ASSERT(consumed <= stream_length);
+    stream_length -= consumed;
+    stream += consumed;
+    if (c > unibrow::Utf16::kMaxNonSurrogateCharCode) {
+      len -= 2;
+      if (len < 0) break;
+      *chars++ = unibrow::Utf16::LeadSurrogate(c);
+      *chars++ = unibrow::Utf16::TrailSurrogate(c);
+    } else {
+      len -= 1;
+      if (len < 0) break;
+      *chars++ = c;
+    }
+  }
+  ASSERT(stream_length == 0);
+  ASSERT(len == 0);
+}
 
 
-template<>
-class AllocateInternalSymbolHelper< Vector<const char> > {
- public:
-  static inline void WriteOneByteData(Vector<const char> vector,
-                                      uint8_t* chars,
-                                      int len) {
-    // Only works for ascii.
-    ASSERT(vector.length() == len);
-    memcpy(chars, vector.start(), len);
-  }
+static inline void WriteOneByteData(String* s, uint8_t* chars, int len) {
+  ASSERT(s->length() == len);
+  String::WriteToFlat(s, chars, 0, len);
+}
 
-  static inline void WriteTwoByteData(Vector<const char> vector,
-                                      uint16_t* chars,
-                                      int len) {
-    const uint8_t* stream = reinterpret_cast<const uint8_t*>(vector.start());
-    unsigned stream_length = vector.length();
-    while (stream_length != 0) {
-      unsigned consumed = 0;
-      uint32_t c = unibrow::Utf8::ValueOf(stream, stream_length, &consumed);
-      ASSERT(c != unibrow::Utf8::kBadChar);
-      ASSERT(consumed <= stream_length);
-      stream_length -= consumed;
-      stream += consumed;
-      if (c > unibrow::Utf16::kMaxNonSurrogateCharCode) {
-        len -= 2;
-        if (len < 0) break;
-        *chars++ = unibrow::Utf16::LeadSurrogate(c);
-        *chars++ = unibrow::Utf16::TrailSurrogate(c);
-      } else {
-        len -= 1;
-        if (len < 0) break;
-        *chars++ = c;
-      }
-    }
-    ASSERT(stream_length == 0);
-    ASSERT(len == 0);
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(AllocateInternalSymbolHelper);
-};
-
-
-template<>
-class AllocateInternalSymbolHelper<String*> {
- public:
-  static inline void WriteOneByteData(String* s, uint8_t* chars, int len) {
-    ASSERT(s->length() == len);
-    String::WriteToFlat(s, chars, 0, len);
-  }
-
-  static inline void WriteTwoByteData(String* s, uint16_t* chars, int len) {
-    ASSERT(s->length() == len);
-    String::WriteToFlat(s, chars, 0, len);
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(AllocateInternalSymbolHelper<String*>);
-};
+static inline void WriteTwoByteData(String* s, uint16_t* chars, int len) {
+  ASSERT(s->length() == len);
+  String::WriteToFlat(s, chars, 0, len);
+}
 
 
 template<bool is_one_byte, typename T>
 MaybeObject* Heap::AllocateInternalSymbol(T t,
                                           int chars,
                                           uint32_t hash_field) {
-  typedef AllocateInternalSymbolHelper<T> H;
   ASSERT(chars >= 0);
   // Compute map and object size.
   int size;
   Map* map;
 
   if (is_one_byte) {
     if (chars > SeqOneByteString::kMaxLength) {
       return Failure::OutOfMemoryException(0x9);
     }
     map = ascii_symbol_map();
@@ skipping 16 matching lines @@
 
   reinterpret_cast<HeapObject*>(result)->set_map_no_write_barrier(map);
   // Set length and hash fields of the allocated string.
   String* answer = String::cast(result);
   answer->set_length(chars);
   answer->set_hash_field(hash_field);
 
   ASSERT_EQ(size, answer->Size());
 
   if (is_one_byte) {
-    H::WriteOneByteData(t, SeqOneByteString::cast(answer)->GetChars(), chars);
+    WriteOneByteData(t, SeqOneByteString::cast(answer)->GetChars(), chars);
   } else {
-    H::WriteTwoByteData(t, SeqTwoByteString::cast(answer)->GetChars(), chars);
+    WriteTwoByteData(t, SeqTwoByteString::cast(answer)->GetChars(), chars);
   }
   return answer;
 }
 
 
 // Need explicit instantiations.
 template
 MaybeObject* Heap::AllocateInternalSymbol<true>(String*, int, uint32_t);
 template
 MaybeObject* Heap::AllocateInternalSymbol<false>(String*, int, uint32_t);
@@ skipping 2730 matching lines @@
       static_cast<int>(object_sizes_last_time_[index]));
   FIXED_ARRAY_SUB_INSTANCE_TYPE_LIST(ADJUST_LAST_TIME_OBJECT_COUNT)
 #undef ADJUST_LAST_TIME_OBJECT_COUNT
 
   memcpy(object_counts_last_time_, object_counts_, sizeof(object_counts_));
   memcpy(object_sizes_last_time_, object_sizes_, sizeof(object_sizes_));
   ClearObjectStats();
 }
 
 } }  // namespace v8::internal