Remove comparison operator and helper function from AstRawString interface

src/ast-value-factory.h

 // Copyright 2014 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 52 matching lines @@
 
 
 class AstRawString : public AstString {
  public:
   int length() const OVERRIDE {
     if (is_one_byte_)
       return literal_bytes_.length();
     return literal_bytes_.length() / 2;
   }
 
+  int byte_length() const { return literal_bytes_.length(); }
+
   void Internalize(Isolate* isolate) OVERRIDE;
 
   bool AsArrayIndex(uint32_t* index) const;
 
   // The string is not null-terminated, use length() to find out the length.
   const unsigned char* raw_data() const {
     return literal_bytes_.start();
   }
   bool is_one_byte() const { return is_one_byte_; }
   bool IsOneByteEqualTo(const char* data) const;
   uint16_t FirstCharacter() const {
     if (is_one_byte_)
       return literal_bytes_[0];
     const uint16_t* c =
         reinterpret_cast<const uint16_t*>(literal_bytes_.start());
     return *c;
   }
 
   // For storing AstRawStrings in a hash map.
   uint32_t hash() const {
     return hash_;
   }
-  static bool Compare(void* a, void* b);
-
-  bool operator==(const AstRawString& rhs) const;
 
  private:
   friend class AstValueFactory;
   friend class AstRawStringInternalizationKey;
 
   AstRawString(bool is_one_byte, const Vector<const byte>& literal_bytes,
             uint32_t hash)
       : is_one_byte_(is_one_byte), literal_bytes_(literal_bytes), hash_(hash) {}
 
   AstRawString()
@@ skipping 162 matching lines @@
 #define OTHER_CONSTANTS(F) \
   F(true_value)            \
   F(false_value)           \
   F(null_value)            \
   F(undefined_value)       \
   F(the_hole_value)
 
 class AstValueFactory {
  public:
   AstValueFactory(Zone* zone, uint32_t hash_seed)
-      : string_table_(AstRawString::Compare),
+      : string_table_(AstRawStringCompare),
         zone_(zone),
         isolate_(NULL),
         hash_seed_(hash_seed) {
 #define F(name, str) name##_string_ = NULL;
     STRING_CONSTANTS(F)
 #undef F
 #define F(name) name##_ = NULL;
     OTHER_CONSTANTS(F)
 #undef F
   }
@@ skipping 42 matching lines @@
   const AstValue* NewNull();
   const AstValue* NewUndefined();
   const AstValue* NewTheHole();
 
  private:
   AstRawString* GetOneByteStringInternal(Vector<const uint8_t> literal);
   AstRawString* GetTwoByteStringInternal(Vector<const uint16_t> literal);
   AstRawString* GetString(uint32_t hash, bool is_one_byte,
                           Vector<const byte> literal_bytes);
 
+  static bool AstRawStringCompare(void* a, void* b);
+
   // All strings are copied here, one after another (no NULLs inbetween).
   HashMap string_table_;
   // For keeping track of all AstValues and AstRawStrings we've created (so that
   // they can be internalized later).
   List<AstValue*> values_;
   List<AstString*> strings_;
   Zone* zone_;
   Isolate* isolate_;
 
   uint32_t hash_seed_;
 
 #define F(name, str) const AstRawString* name##_string_;
   STRING_CONSTANTS(F)
 #undef F
 
 #define F(name) AstValue* name##_;
   OTHER_CONSTANTS(F)
 #undef F
 };
 } }  // namespace v8::internal
 
 #undef STRING_CONSTANTS
 #undef OTHER_CONSTANTS
 
 #endif  // V8_AST_VALUE_FACTORY_H_