Fix up internalized strings after deserializing user code.

test/cctest/test-serialize.cc

 // Copyright 2007-2010 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 657 matching lines @@
   HeapIterator iterator(CcTest::heap());
   DisallowHeapAllocation no_allocation;
   int counter = 0;
   for (HeapObject* obj = iterator.next(); obj != NULL; obj = iterator.next()) {
     if (obj->IsCode() && Code::cast(obj)->kind() == Code::BUILTIN) counter++;
   }
   return counter;
 }
 
 
-TEST(SerializeToplevel) {
+TEST(SerializeToplevelOnePlusOne) {
   FLAG_serialize_toplevel = true;
+  LocalContext context;
   v8::HandleScope scope(CcTest::isolate());
-  v8::Local<v8::Context> context = CcTest::NewContext(PRINT_EXTENSION);
-  v8::Context::Scope context_scope(context);
 
   const char* source1 = "1 + 1";
   const char* source2 = "1 + 2";  // Use alternate string to verify caching.
 
   Isolate* isolate = CcTest::i_isolate();
   Handle<String> source1_string = isolate->factory()
                                       ->NewStringFromUtf8(CStrVector(source1))
                                       .ToHandleChecked();
 
   Handle<String> source2_string = isolate->factory()
                                       ->NewStringFromUtf8(CStrVector(source2))
                                       .ToHandleChecked();
 
   ScriptData* cache = NULL;
 
   Handle<SharedFunctionInfo> orig =
       Compiler::CompileScript(source1_string, Handle<String>(), 0, 0, false,
                               Handle<Context>(isolate->native_context()), NULL,
                               &cache, PRODUCE_CACHED_DATA, NOT_NATIVES_CODE);
 
   int builtins_count = CountBuiltins();
 
-  Handle<SharedFunctionInfo> info =
+  Handle<SharedFunctionInfo> copy =
       Compiler::CompileScript(source2_string, Handle<String>(), 0, 0, false,
                               Handle<Context>(isolate->native_context()), NULL,
                               &cache, CONSUME_CACHED_DATA, NOT_NATIVES_CODE);
 
-  CHECK_NE(*orig, *info);
-  Handle<JSFunction> fun =
+  CHECK_NE(*orig, *copy);
+  Handle<JSFunction> copy_fun =
       isolate->factory()->NewFunctionFromSharedFunctionInfo(
-          info, isolate->native_context());
+          copy, isolate->native_context());
   Handle<JSObject> global(isolate->context()->global_object());
-  Handle<Object> result =
-      Execution::Call(isolate, fun, global, 0, NULL).ToHandleChecked();
-  CHECK_EQ(2, Handle<Smi>::cast(result)->value());
+  Handle<Object> copy_result =
+      Execution::Call(isolate, copy_fun, global, 0, NULL).ToHandleChecked();
+  CHECK_EQ(2, Handle<Smi>::cast(copy_result)->value());
 
   CHECK_EQ(builtins_count, CountBuiltins());
 
   delete cache;
 }
+
+
+TEST(SerializeToplevelInternalizedString) {

[mvstanton, 2014/07/14 13:31:03]

Per our discussion, it might be nice in debug mode to try and prevent a mismatch
between a script and cache data for that script. It makes sense to say it's up
to the embedder to avoid that, but maybe we can do something in debug mode. We
talked about the source string (slated to be removed), about the notion of a CRC
on the source string (too expensive, at least in release), and about the notion
of a version.

+  FLAG_serialize_toplevel = true;
+  LocalContext context;
+  v8::HandleScope scope(CcTest::isolate());
+
+  const char* source1 = "'string1'";
+  const char* source2 = "'string2'";  // Use alternate string to verify caching.
+
+  Isolate* isolate = CcTest::i_isolate();
+  Handle<String> source1_string = isolate->factory()
+                                      ->NewStringFromUtf8(CStrVector(source1))
+                                      .ToHandleChecked();
+
+  Handle<String> source2_string = isolate->factory()
+                                      ->NewStringFromUtf8(CStrVector(source2))
+                                      .ToHandleChecked();
+  Handle<JSObject> global(isolate->context()->global_object());
+  ScriptData* cache = NULL;
+
+  Handle<SharedFunctionInfo> orig =
+      Compiler::CompileScript(source1_string, Handle<String>(), 0, 0, false,
+                              Handle<Context>(isolate->native_context()), NULL,
+                              &cache, PRODUCE_CACHED_DATA, NOT_NATIVES_CODE);
+  Handle<JSFunction> orig_fun =
+      isolate->factory()->NewFunctionFromSharedFunctionInfo(
+          orig, isolate->native_context());
+  Handle<Object> orig_result =
+      Execution::Call(isolate, orig_fun, global, 0, NULL).ToHandleChecked();
+  CHECK(orig_result->IsInternalizedString());
+
+  int builtins_count = CountBuiltins();
+
+  Handle<SharedFunctionInfo> copy =
+      Compiler::CompileScript(source2_string, Handle<String>(), 0, 0, false,
+                              Handle<Context>(isolate->native_context()), NULL,
+                              &cache, CONSUME_CACHED_DATA, NOT_NATIVES_CODE);
+  CHECK_NE(*orig, *copy);
+  Handle<JSFunction> copy_fun =
+      isolate->factory()->NewFunctionFromSharedFunctionInfo(
+          copy, isolate->native_context());
+  CHECK_NE(*orig_fun, *copy_fun);
+  Handle<Object> copy_result =
+      Execution::Call(isolate, copy_fun, global, 0, NULL).ToHandleChecked();
+  CHECK(orig_result.is_identical_to(copy_result));
+  Handle<String> expected =
+      isolate->factory()->NewStringFromAsciiChecked("string1");
+
+  CHECK(Handle<String>::cast(copy_result)->Equals(*expected));
+  CHECK_EQ(builtins_count, CountBuiltins());
+
+  delete cache;
+}