Revert "Added ability to lock strings to prevent their representation or encoding from changing."

test/cctest/test-api.cc

 // 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 15 matching lines @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <limits.h>
 
 #include "v8.h"
 
 #include "api.h"
 #include "isolate.h"
 #include "compilation-cache.h"
 #include "execution.h"
-#include "handles.h"
 #include "snapshot.h"
 #include "platform.h"
 #include "utils.h"
 #include "cctest.h"
 #include "parser.h"
 #include "unicode-inl.h"
 
 static const bool kLogThreading = false;
 
 static bool IsNaN(double x) {
@@ skipping 15387 matching lines @@
   CHECK(i->Equals(CompileRun("'abcbd'.replace(/b/g,func)[3]")));
 
   // TODO(1547): Make the following also return "i".
   // Calling with environment record as base.
   TestReceiver(o, context->Global(), "func()");
   // Calling with no base.
   TestReceiver(o, context->Global(), "(1,func)()");
 
   foreign_context.Dispose();
 }
-
-
-
-class SimpleTestResource: public String::ExternalStringResource {
- public:
-  explicit SimpleTestResource(const uint16_t* data) : data_(data), length_(0) {
-    while (data[length_] != 0) length_++;
-  }
-  virtual ~SimpleTestResource() { }
-  virtual const uint16_t* data() const { return data_; }
-  virtual size_t length() const { return length_; }
- private:
-  const uint16_t* data_;
-  int length_;
-};
-
-
-THREADED_TEST(StringLock) {
-  v8::HandleScope scope;
-  LocalContext env;
-
-  i::Isolate* isolate = i::Isolate::Current();
-  i::Heap* heap = isolate->heap();
-
-  // ASCII text of test strings.
-  const char* text = "Lorem ipsum dolor sic amet.";
-  const size_t kTextLength = 27;
-  CHECK(strlen(text) == kTextLength);
-  // UC16 version of string.
-  uint16_t uc16_text[kTextLength + 1];
-  for (unsigned i = 0; i <= kTextLength; i++) {
-    uc16_text[i] = static_cast<uint16_t>(text[i]);
-  }
-
-  // Create some different strings and move them to old-space,
-  // so that externalization can succeede.
-  Local<String> s1 = v8_str(text);
-  Local<String> s2 = v8_str(text + 1);
-  Local<String> s3 = v8_str(text + 2);
-  heap->CollectGarbage(i::NEW_SPACE);
-  heap->CollectGarbage(i::NEW_SPACE);
-
-  SimpleTestResource* r1 = new SimpleTestResource(uc16_text);
-  SimpleTestResource* r2 = new SimpleTestResource(uc16_text + 1);
-  SimpleTestResource* r3 = new SimpleTestResource(uc16_text + 2);
-
-  // Check that externalization works.
-  CHECK(!s1->IsExternal());
-  CHECK(s1->MakeExternal(r1));
-  CHECK(s1->IsExternal());
-
-  // Externalize while the string is locked.
-
-  // Use the direct interface to string locking.
-  i::Handle<i::String> s2i(v8::Utils::OpenHandle(*s2));
-  CHECK(!heap->IsStringLocked(*s2i));
-  LockString(s2i);  // Use handle version, not Heap::LockString, to allow GC.
-  CHECK(isolate->heap()->IsStringLocked(*s2i));
-
-  CHECK(!s2->IsExternal());
-  CHECK(!s2->MakeExternal(r2));
-  CHECK(!s2->IsExternal());
-
-  CHECK(heap->IsStringLocked(*s2i));
-  heap->UnlockString(*s2i);
-  CHECK(!heap->IsStringLocked(*s2i));
-
-  CHECK(!s2->IsExternal());
-  CHECK(s2->MakeExternal(r2));
-  CHECK(s2->IsExternal());
-
-  // Use the Handle-based scoped StringLock.
-  i::Handle<i::String> s3i(v8::Utils::OpenHandle(*s3));
-  {
-    CHECK(!heap->IsStringLocked(*s3i));
-    i::StringLock lock(s3i);
-    CHECK(heap->IsStringLocked(*s3i));
-
-    CHECK(!s3->IsExternal());
-    CHECK(!s3->MakeExternal(r3));
-    CHECK(!s3->IsExternal());
-
-    CHECK(heap->IsStringLocked(*s3i));
-  }
-  CHECK(!heap->IsStringLocked(*s3i));
-
-  CHECK(!s3->IsExternal());
-  CHECK(s3->MakeExternal(r3));
-  CHECK(s3->IsExternal());
-}
-
-
-THREADED_TEST(MultiStringLock) {
-  v8::HandleScope scope;
-  LocalContext env;
-  i::Isolate* isolate = i::Isolate::Current();
-  i::Heap* heap = isolate->heap();
-  const char* text = "Lorem ipsum dolor sic amet.";
-
-  const int N = 16;  // Must be power of 2.
-  CHECK_GT(strlen(text), static_cast<size_t>(N));
-
-  // Create a bunch of different strings.
-  i::Handle<i::String> strings[N];
-
-  for (int i = 0; i < N; i++) {
-    Local<String> s = v8_str(text + i);
-    strings[i] = v8::Utils::OpenHandle(*s);
-  }
-
-  heap->CollectGarbage(i::NEW_SPACE);
-  heap->CollectGarbage(i::NEW_SPACE);
-
-  // Check that start out are unlocked.
-  for (int i = 0; i < N; i++) {
-    CHECK(!heap->IsStringLocked(*strings[i]));
-  }
-
-  // Lock them, one at a time.
-  for (int i = 0; i < N; i++) {
-    LockString(strings[i]);
-    for (int j = 0; j < N; j++) {
-      if (j <= i) {
-        CHECK(heap->IsStringLocked(*strings[j]));
-      } else {
-        CHECK(!heap->IsStringLocked(*strings[j]));
-      }
-    }
-  }
-
-  // Unlock them in a slightly different order (not same as locking,
-  // nor the reverse order).
-  for (int i = 0; i < N; i++) {
-    int mix_i = i ^ 3;
-    heap->UnlockString(*strings[mix_i]);
-    for (int j = 0; j < N; j++) {
-      int unmix_j =  j ^ 3;
-      if (unmix_j <= i) {
-        CHECK(!heap->IsStringLocked(*strings[j]));
-      } else {
-        CHECK(heap->IsStringLocked(*strings[j]));
-      }
-    }
-  }
-}
-
-
-THREADED_TEST(DuplicateStringLock) {
-  v8::HandleScope scope;
-  LocalContext env;
-  i::Isolate* isolate = i::Isolate::Current();
-  i::Heap* heap = isolate->heap();
-  const char* text = "Lorem ipsum dolor sic amet.";
-
-  const int N = 16;  // Must be power of 2.
-  CHECK_GT(strlen(text), static_cast<size_t>(N));
-
-  // Create a bunch of different strings.
-  i::Handle<i::String> strings[N];
-
-  for (int i = 0; i < N; i++) {
-    Local<String> s = v8_str(text + i);
-    strings[i] = v8::Utils::OpenHandle(*s);
-  }
-
-  heap->CollectGarbage(i::NEW_SPACE);
-  heap->CollectGarbage(i::NEW_SPACE);
-
-  // Check that strings start out unlocked.
-  for (int i = 0; i < N; i++) {
-    CHECK(!heap->IsStringLocked(*strings[i]));
-  }
-
-  // Lock them, one at a time.
-  for (int i = 0; i < N; i++) {
-    LockString(strings[i]);
-    for (int j = 0; j < N; j++) {
-      if (j <= i) {
-        CHECK(heap->IsStringLocked(*strings[j]));
-      } else {
-        CHECK(!heap->IsStringLocked(*strings[j]));
-      }
-    }
-  }
-
-  // Lock the first half of them a second time.
-  for (int i = 0; i < N / 2; i++) {
-    LockString(strings[i]);
-    for (int j = 0; j < N; j++) {
-      CHECK(heap->IsStringLocked(*strings[j]));
-    }
-  }
-
-  // Unlock them in a slightly different order (not same as locking,
-  // nor the reverse order).
-  for (int i = 0; i < N; i++) {
-    int mix_i = i ^ 3;
-    heap->UnlockString(*strings[mix_i]);
-    for (int j = 0; j < N; j++) {
-      int unmix_j =  j ^ 3;
-      if (unmix_j <= i && j >= N / 2) {
-        CHECK(!heap->IsStringLocked(*strings[j]));
-      } else {
-        CHECK(heap->IsStringLocked(*strings[j]));
-      }
-    }
-  }
-
-  // Unlock the first half again.
-  for (int i = 0; i < N / 2; i++) {
-    heap->UnlockString(*strings[i]);
-    for (int j = 0; j < N; j++) {
-      if (j <= i || j >= N/ 2) {
-        CHECK(!heap->IsStringLocked(*strings[j]));
-      } else {
-        CHECK(heap->IsStringLocked(*strings[j]));
-      }
-    }
-  }
-}