Minor changes based on the profile while running dart2js compile all.

vm/object.h

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 3172 matching lines @@
   static intptr_t hash_offset() { return OFFSET_OF(RawString, hash_); }
   static intptr_t Hash(const String& str, intptr_t begin_index, intptr_t len);
   static intptr_t Hash(const uint8_t* characters, intptr_t len);
   static intptr_t Hash(const uint16_t* characters, intptr_t len);
   static intptr_t Hash(const uint32_t* characters, intptr_t len);
 
   virtual int32_t CharAt(intptr_t index) const;
 
   virtual intptr_t CharSize() const;
 
-  bool Equals(const String& str) const {
-    if (raw() == str.raw()) {
-      return true;  // Both handles point to the same raw instance.
-    }
-    if (str.IsNull()) {
-      return false;
-    }
-    return Equals(str, 0, str.Length());
-  }
-  bool Equals(const String& str, intptr_t begin_index, intptr_t len) const;
+  inline bool Equals(const String& str) const;
+  inline bool Equals(const String& str,
+                     intptr_t begin_index,  // begin index on 'str'.
+                     intptr_t len) const;  // len on 'str'.
   bool Equals(const char* str) const;
   bool Equals(const uint8_t* characters, intptr_t len) const;
   bool Equals(const uint16_t* characters, intptr_t len) const;
   bool Equals(const uint32_t* characters, intptr_t len) const;
 
   virtual bool Equals(const Instance& other) const;
 
   intptr_t CompareTo(const String& other) const;
 
   bool StartsWith(const String& other) const;
@@ skipping 122 matching lines @@
   virtual int32_t CharAt(intptr_t index) const {
     return *CharAddr(index);
   }
 
   virtual intptr_t CharSize() const {
     return kOneByteChar;
   }
 
   RawOneByteString* EscapeDoubleQuotes() const;
 
+  bool EqualsIgnoringPrivateKey(const OneByteString& str) const;
+
   static intptr_t data_offset() { return OFFSET_OF(RawOneByteString, data_); }
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawOneByteString) == OFFSET_OF(RawOneByteString, data_));
     return 0;
   }
 
   static intptr_t InstanceSize(intptr_t len) {
     return RoundedAllocationSize(sizeof(RawOneByteString) + len);
   }
 
   static RawOneByteString* New(intptr_t len,
                                Heap::Space space);
+  static RawOneByteString* New(const char* c_string,
+                               Heap::Space space = Heap::kNew) {
+    return New(reinterpret_cast<const uint8_t*>(c_string),
+               strlen(c_string),
+               space);
+  }
   static RawOneByteString* New(const uint8_t* characters,
                                intptr_t len,
                                Heap::Space space);
   static RawOneByteString* New(const uint16_t* characters,
                                intptr_t len,
                                Heap::Space space);
   static RawOneByteString* New(const uint32_t* characters,
                                intptr_t len,
                                Heap::Space space);
   static RawOneByteString* New(const OneByteString& str,
@@ skipping 1765 matching lines @@
 
 void Context::SetAt(intptr_t index, const Instance& value) const {
   StorePointer(InstanceAddr(index), value.raw());
 }
 
 
 intptr_t Stackmap::SizeInBits() const {
   return (Smi::Value(raw_ptr()->bitmap_size_in_bytes_) * kBitsPerByte);
 }
 
+
+bool String::Equals(const String& str) const {
+  if (raw() == str.raw()) {
+    return true;  // Both handles point to the same raw instance.
+  }
+  if (str.IsNull()) {
+    return false;
+  }
+  return Equals(str, 0, str.Length());
+}
+
+
+bool String::Equals(const String& str,
+                    intptr_t begin_index,
+                    intptr_t len) const {
+  ASSERT(begin_index >= 0);
+  ASSERT((begin_index == 0) || (begin_index < str.Length()));
+  ASSERT(len >= 0);
+  ASSERT(len <= str.Length());
+  if (len != this->Length()) {
+    return false;  // Lengths don't match.
+  }
+  for (intptr_t i = 0; i < len; i++) {
+    if (this->CharAt(i) != str.CharAt(begin_index + i)) {
+      return false;
+    }
+  }
+  return true;
+}
+
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_