Revert trunk to version 3.16.4.

src/api.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 1844 matching lines @@
 }
 
 
 v8::Local<Value> v8::TryCatch::StackTrace() const {
   ASSERT(isolate_ == i::Isolate::Current());
   if (HasCaught()) {
     i::Object* raw_obj = reinterpret_cast<i::Object*>(exception_);
     if (!raw_obj->IsJSObject()) return v8::Local<Value>();
     i::HandleScope scope(isolate_);
     i::Handle<i::JSObject> obj(i::JSObject::cast(raw_obj), isolate_);
-    i::Handle<i::String> name = isolate_->factory()->stack_symbol();
+    i::Handle<i::String> name =
+        isolate_->factory()->LookupOneByteSymbol(STATIC_ASCII_VECTOR("stack"));
     if (!obj->HasProperty(*name)) return v8::Local<Value>();
     i::Handle<i::Object> value = i::GetProperty(obj, name);
     if (value.is_null()) return v8::Local<Value>();
     return v8::Utils::ToLocal(scope.CloseAndEscape(value));
   } else {
     return v8::Local<Value>();
   }
 }
 
 
@@ skipping 2009 matching lines @@
 
 bool String::MayContainNonAscii() const {
   i::Handle<i::String> str = Utils::OpenHandle(this);
   if (IsDeadCheck(str->GetIsolate(), "v8::String::MayContainNonAscii()")) {
     return false;
   }
   return !str->HasOnlyAsciiChars();
 }
 
 
-bool String::IsOneByte() const {
-  i::Handle<i::String> str = Utils::OpenHandle(this);
-  if (IsDeadCheck(str->GetIsolate(), "v8::String::IsOneByte()")) {
-    return false;
-  }
-  return str->IsOneByteConvertible();
-}
-
-
 class Utf8LengthVisitor {
  public:
   explicit Utf8LengthVisitor()
     : utf8_length_(0),
       last_character_(unibrow::Utf16::kNoPreviousCharacter) {}
 
   inline int GetLength() {
     return utf8_length_;
   }
 
@@ skipping 281 matching lines @@
     if (c == '\0' && !(options & PRESERVE_ASCII_NULL)) c = ' ';
     buffer[i] = c;
   }
   if (!(options & NO_NULL_TERMINATION) && (length == -1 || i < length)) {
     buffer[i] = '\0';
   }
   return i;
 }
 
 
-template<typename CharType>
-struct WriteHelper {
-  static inline int Write(const String* string,
-                          CharType* buffer,
-                          int start,
-                          int length,
-                          int options) {
-    i::Isolate* isolate = Utils::OpenHandle(string)->GetIsolate();
-    if (IsDeadCheck(isolate, "v8::String::Write()")) return 0;
-    LOG_API(isolate, "String::Write");
-    ENTER_V8(isolate);
-    ASSERT(start >= 0 && length >= -1);
-    i::Handle<i::String> str = Utils::OpenHandle(string);
-    isolate->string_tracker()->RecordWrite(str);
-    if (options & String::HINT_MANY_WRITES_EXPECTED) {
-      // Flatten the string for efficiency.  This applies whether we are
-      // using StringCharacterStream or Get(i) to access the characters.
-      FlattenString(str);
-    }
-    int end = start + length;
-    if ((length == -1) || (length > str->length() - start) )
-      end = str->length();
-    if (end < 0) return 0;
-    i::String::WriteToFlat(*str, buffer, start, end);
-    if (!(options & String::NO_NULL_TERMINATION) &&
-        (length == -1 || end - start < length)) {
-      buffer[end - start] = '\0';
-    }
-    return end - start;
-  }
-};
-
-
-int String::WriteOneByte(uint8_t* buffer,
-                         int start,
-                         int length,
-                         int options) const {
-  return WriteHelper<uint8_t>::Write(this, buffer, start, length, options);
-}
-
-
 int String::Write(uint16_t* buffer,
                   int start,
                   int length,
                   int options) const {
-  return WriteHelper<uint16_t>::Write(this, buffer, start, length, options);
+  i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
+  if (IsDeadCheck(isolate, "v8::String::Write()")) return 0;
+  LOG_API(isolate, "String::Write");
+  ENTER_V8(isolate);
+  ASSERT(start >= 0 && length >= -1);
+  i::Handle<i::String> str = Utils::OpenHandle(this);
+  isolate->string_tracker()->RecordWrite(str);
+  if (options & HINT_MANY_WRITES_EXPECTED) {
+    // Flatten the string for efficiency.  This applies whether we are
+    // using StringCharacterStream or Get(i) to access the characters.
+    FlattenString(str);
+  }
+  int end = start + length;
+  if ((length == -1) || (length > str->length() - start) )
+    end = str->length();
+  if (end < 0) return 0;
+  i::String::WriteToFlat(*str, buffer, start, end);
+  if (!(options & NO_NULL_TERMINATION) &&
+      (length == -1 || end - start < length)) {
+    buffer[end - start] = '\0';
+  }
+  return end - start;
 }
 
 
 bool v8::String::IsExternal() const {
   i::Handle<i::String> str = Utils::OpenHandle(this);
   if (IsDeadCheck(str->GetIsolate(), "v8::String::IsExternal()")) {
     return false;
   }
   EnsureInitializedForIsolate(str->GetIsolate(), "v8::String::IsExternal()");
   return i::StringShape(*str).IsExternalTwoByte();
@@ skipping 167 matching lines @@
 
 
 static void* ExternalValue(i::Object* obj) {
   // Obscure semantics for undefined, but somehow checked in our unit tests...
   if (obj->IsUndefined()) return NULL;
   i::Object* foreign = i::JSObject::cast(obj)->GetInternalField(0);
   return i::Foreign::cast(foreign)->foreign_address();
 }
 
 
+void* Object::GetPointerFromInternalField(int index) {
+  i::Handle<i::JSObject> obj = Utils::OpenHandle(this);
+  const char* location = "v8::Object::GetPointerFromInternalField()";
+  if (!InternalFieldOK(obj, index, location)) return NULL;
+  return ExternalValue(obj->GetInternalField(index));
+}
+
+
 // --- E n v i r o n m e n t ---
 
 
 bool v8::V8::Initialize() {
   i::Isolate* isolate = i::Isolate::UncheckedCurrent();
   if (isolate != NULL && isolate->IsInitialized()) {
     return true;
   }
   return InitializeHelper();
 }
@@ skipping 2319 matching lines @@
 
   v->VisitPointers(blocks_.first(), first_block_limit_);
 
   for (int i = 1; i < blocks_.length(); i++) {
     v->VisitPointers(blocks_[i], &blocks_[i][kHandleBlockSize]);
   }
 }
 
 
 } }  // namespace v8::internal