Refactor ScriptData class for cached compile data.

test/cctest/test-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 14796 matching lines @@
   v8::Isolate* isolate = env->GetIsolate();
   HandleScope handle_scope(isolate);
 
   i::FLAG_min_preparse_length = 0;
   const char* script = "function foo(a) { return a+1; }";
   v8::ScriptCompiler::Source source(v8_str(script));
   v8::ScriptCompiler::Compile(isolate, &source,
                               v8::ScriptCompiler::kProduceDataToCache);
   // Serialize.
   const v8::ScriptCompiler::CachedData* cd = source.GetCachedData();
-  char* serialized_data = i::NewArray<char>(cd->length);
+  i::byte* serialized_data = i::NewArray<i::byte>(cd->length);
   i::MemCopy(serialized_data, cd->data, cd->length);
 
   // Deserialize.
-  i::ScriptData* deserialized = i::ScriptData::New(serialized_data, cd->length);
+  i::ScriptData* deserialized = new i::ScriptData(serialized_data, cd->length);
 
   // Verify that the original is the same as the deserialized.
-  CHECK_EQ(cd->length, deserialized->Length());
-  CHECK_EQ(0, memcmp(cd->data, deserialized->Data(), cd->length));
+  CHECK_EQ(cd->length, deserialized->length());
+  CHECK_EQ(0, memcmp(cd->data, deserialized->data(), cd->length));
 
   delete deserialized;
   i::DeleteArray(serialized_data);
 }
 
 
 // Attempts to deserialize bad data.
-TEST(PreCompileDeserializationError) {
+TEST(ExpectFailPreCompileDeserializationError) {

[marja, 2014/07/09 14:42:30]

I'd just remove this test, it makes no sense to keep it as a failing test.

If we cannot assert that a CHECK is hit, but we assert that the test fails, then
it rots very easily. E.g., it can start failing due to some other reason than
ScriptData, and nobody will notice. And after that point, it doesn't test
anything.

[Yang, 2014/07/10 08:28:46]

Done.

   v8::V8::Initialize();
-  const char* data = "DONT CARE";
+  const i::byte data[] = {1, 2, 3, 4};
   int invalid_size = 3;
-  i::ScriptData* sd = i::ScriptData::New(data, invalid_size);
-  CHECK_EQ(NULL, sd);
+  i::ScriptData* sd = new i::ScriptData(data, invalid_size);
+  i::ParseData* pd = new i::ParseData(sd);
+  delete sd;
+  delete pd;
 }
 
 
-TEST(CompileWithInvalidCachedData) {
+static const char* cached_script_source =
+    "function foo(){ return 5;}\n"
+    "function bar(){ return 6 + 7;}  foo();";
+
+
+// ScriptData private implementation details
+static const int kHeaderSize = i::PreparseDataConstants::kHeaderSize;
+static const int kFunctionEntrySize = i::FunctionEntry::kSize;
+static const int kFunctionEntryStartOffset = 0;
+static const int kFunctionEntryEndOffset = 1;
+
+
+TEST(ExpectFailCompileWithInvalidCachedData1) {
   v8::V8::Initialize();
   v8::Isolate* isolate = CcTest::isolate();
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   i::FLAG_min_preparse_length = 0;
 
-  const char* script = "function foo(){ return 5;}\n"
-      "function bar(){ return 6 + 7;}  foo();";
-  v8::ScriptCompiler::Source source(v8_str(script));
+  v8::ScriptCompiler::Source source(v8_str(cached_script_source));
   v8::ScriptCompiler::Compile(isolate, &source,
                               v8::ScriptCompiler::kProduceDataToCache);
   // source owns its cached data. Create a ScriptData based on it. The user
   // never needs to create ScriptDatas any more; we only need it here because we
   // want to modify the data before passing it back.
   const v8::ScriptCompiler::CachedData* cd = source.GetCachedData();
   // ScriptData does not take ownership of the buffers passed to it.
-  i::ScriptData* sd =
-      i::ScriptData::New(reinterpret_cast<const char*>(cd->data), cd->length);
-  CHECK(!sd->HasError());
-  // ScriptData private implementation details
-  const int kHeaderSize = i::PreparseDataConstants::kHeaderSize;
-  const int kFunctionEntrySize = i::FunctionEntry::kSize;
-  const int kFunctionEntryStartOffset = 0;
-  const int kFunctionEntryEndOffset = 1;
-  unsigned* sd_data =
-      reinterpret_cast<unsigned*>(const_cast<char*>(sd->Data()));
+  i::ScriptData* sd = new i::ScriptData(cd->data, cd->length);
+  i::ParseData pd(sd);
+  CHECK(!pd.HasError());
+  unsigned* pd_data = pd.Data();
 
   // Overwrite function bar's end position with 0.
-  sd_data[kHeaderSize + 1 * kFunctionEntrySize + kFunctionEntryEndOffset] = 0;
-  v8::TryCatch try_catch;
+  pd_data[kHeaderSize + 1 * kFunctionEntrySize + kFunctionEntryEndOffset] = 0;
 
   // Make the script slightly different so that we don't hit the compilation
   // cache. Don't change the lenghts of tokens.
   const char* script2 = "function foo(){ return 6;}\n"
       "function bar(){ return 6 + 7;}  foo();";
   v8::ScriptCompiler::Source source2(
       v8_str(script2),
       // CachedData doesn't take ownership of the buffers, Source takes
       // ownership of CachedData.
-      new v8::ScriptCompiler::CachedData(
-          reinterpret_cast<const uint8_t*>(sd->Data()), sd->Length()));
-  Local<v8::UnboundScript> compiled_script =
-      v8::ScriptCompiler::CompileUnbound(isolate, &source2);
+      new v8::ScriptCompiler::CachedData(sd->data(), sd->length()));
+  v8::ScriptCompiler::CompileUnbound(isolate, &source2);
 
-  CHECK(try_catch.HasCaught());
-  {
-    String::Utf8Value exception_value(try_catch.Message()->Get());
-    CHECK_EQ("Uncaught SyntaxError: Invalid cached data for function bar",
-             *exception_value);
-  }
+  delete sd;
+}
 
-  try_catch.Reset();
-  delete sd;
+
+TEST(ExpectFailCompileWithInvalidCachedData2) {
+  v8::V8::Initialize();
+  v8::Isolate* isolate = CcTest::isolate();
+  LocalContext context;
+  v8::HandleScope scope(context->GetIsolate());
+  i::FLAG_min_preparse_length = 0;
+
+  v8::ScriptCompiler::Source source(v8_str(cached_script_source));
+  v8::ScriptCompiler::Compile(isolate, &source,
+                              v8::ScriptCompiler::kProduceDataToCache);
+  // source owns its cached data. Create a ScriptData based on it. The user
+  // never needs to create ScriptDatas any more; we only need it here because we
+  // want to modify the data before passing it back.
+  const v8::ScriptCompiler::CachedData* cd = source.GetCachedData();
+  // ScriptData does not take ownership of the buffers passed to it.
+  i::ScriptData* sd = new i::ScriptData(cd->data, cd->length);
+  i::ParseData pd(sd);
 
   // Overwrite function bar's start position with 200. The function entry will
   // not be found when searching for it by position, and the compilation fails.
-
   // ScriptData does not take ownership of the buffers passed to it.
-  sd = i::ScriptData::New(reinterpret_cast<const char*>(cd->data), cd->length);
-  sd_data = reinterpret_cast<unsigned*>(const_cast<char*>(sd->Data()));
-  sd_data[kHeaderSize + 1 * kFunctionEntrySize + kFunctionEntryStartOffset] =
+  unsigned* pd_data = pd.Data();
+  pd_data[kHeaderSize + 1 * kFunctionEntrySize + kFunctionEntryStartOffset] =
       200;
-  const char* script3 = "function foo(){ return 7;}\n"
+  const char* script2 =
+      "function foo(){ return 7;}\n"
       "function bar(){ return 6 + 7;}  foo();";
-  v8::ScriptCompiler::Source source3(
-      v8_str(script3),
-      new v8::ScriptCompiler::CachedData(
-          reinterpret_cast<const uint8_t*>(sd->Data()), sd->Length()));
-  compiled_script =
-      v8::ScriptCompiler::CompileUnbound(isolate, &source3);
-  CHECK(try_catch.HasCaught());
-  {
-    String::Utf8Value exception_value(try_catch.Message()->Get());
-    CHECK_EQ("Uncaught SyntaxError: Invalid cached data for function bar",
-             *exception_value);
-  }
-  CHECK(compiled_script.IsEmpty());
-  try_catch.Reset();
-  delete sd;
-
-  // Try passing in cached data which is obviously invalid (wrong length).
-  sd = i::ScriptData::New(reinterpret_cast<const char*>(cd->data), cd->length);
-  const char* script4 =
-      "function foo(){ return 8;}\n"
-      "function bar(){ return 6 + 7;}  foo();";
-  v8::ScriptCompiler::Source source4(
-      v8_str(script4),
-      new v8::ScriptCompiler::CachedData(
-          reinterpret_cast<const uint8_t*>(sd->Data()), sd->Length() - 1));
-  compiled_script =
-      v8::ScriptCompiler::CompileUnbound(isolate, &source4);
-  CHECK(try_catch.HasCaught());
-  {
-    String::Utf8Value exception_value(try_catch.Message()->Get());
-    CHECK_EQ("Uncaught SyntaxError: Invalid cached data",
-             *exception_value);
-  }
-  CHECK(compiled_script.IsEmpty());
+  v8::ScriptCompiler::Source source2(
+      v8_str(script2),
+      new v8::ScriptCompiler::CachedData(sd->data(), sd->length()));
+  v8::ScriptCompiler::CompileUnbound(isolate, &source2);
   delete sd;
 }
 
+
+TEST(ExpectFailCompileWithInvalidCachedData3) {
+  v8::V8::Initialize();
+  v8::Isolate* isolate = CcTest::isolate();
+  LocalContext context;
+  v8::HandleScope scope(context->GetIsolate());
+  i::FLAG_min_preparse_length = 0;
+
+  v8::ScriptCompiler::Source source(v8_str(cached_script_source));
+  v8::ScriptCompiler::Compile(isolate, &source,
+                              v8::ScriptCompiler::kProduceDataToCache);
+  // source owns its cached data. Create a ScriptData based on it. The user
+  // never needs to create ScriptDatas any more; we only need it here because we
+  // want to modify the data before passing it back.
+  const v8::ScriptCompiler::CachedData* cd = source.GetCachedData();
+  // ScriptData does not take ownership of the buffers passed to it.
+  i::ScriptData* sd = new i::ScriptData(cd->data, cd->length);
+
+  // Try passing in cached data which is obviously invalid (wrong length).
+  const char* script2 =
+      "function foo(){ return 8;}\n"
+      "function bar(){ return 6 + 7;}  foo();";
+  v8::ScriptCompiler::Source source2(
+      v8_str(script2),
+      new v8::ScriptCompiler::CachedData(sd->data(), sd->length() - 1));
+  v8::ScriptCompiler::CompileUnbound(isolate, &source2);
+  delete sd;
+}
+
 
 // This tests that we do not allow dictionary load/call inline caches
 // to use functions that have not yet been compiled.  The potential
 // problem of loading a function that has not yet been compiled can
 // arise because we share code between contexts via the compilation
 // cache.
 THREADED_TEST(DictionaryICLoadedFunction) {
   v8::HandleScope scope(CcTest::isolate());
   // Test LoadIC.
   for (int i = 0; i < 2; i++) {
@@ skipping 7935 matching lines @@
   desc = x->GetOwnPropertyDescriptor(v8_str("p1"));
   Local<Function> set =
     Local<Function>::Cast(Local<Object>::Cast(desc)->Get(v8_str("set")));
   Local<Function> get =
     Local<Function>::Cast(Local<Object>::Cast(desc)->Get(v8_str("get")));
   CHECK_EQ(v8_num(13), get->Call(x, 0, NULL));
   Handle<Value> args[] = { v8_num(14) };
   set->Call(x, 1, args);
   CHECK_EQ(v8_num(14), get->Call(x, 0, NULL));
 }