Fix name clashes in cctests.

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 883 matching lines @@
       Execution::Call(isolate, copy_fun, global, 0, NULL).ToHandleChecked();
 
   CHECK_EQ(6 * 1000000, Handle<String>::cast(copy_result)->length());
   CHECK(isolate->heap()->InSpace(HeapObject::cast(*copy_result), LO_SPACE));
 
   delete cache;
   source.Dispose();
 }
 
 
-class OneByteResource : public v8::String::ExternalOneByteStringResource {
+class SerializerOneByteResource
+    : public v8::String::ExternalOneByteStringResource {
  public:
-  OneByteResource(const char* data, size_t length)
+  SerializerOneByteResource(const char* data, size_t length)
       : data_(data), length_(length) {}
   virtual const char* data() const { return data_; }
   virtual size_t length() const { return length_; }
 
  private:
   const char* data_;
   size_t length_;
 };
 
 
-class TwoByteResource : public v8::String::ExternalStringResource {
+class SerializerTwoByteResource : public v8::String::ExternalStringResource {
  public:
-  TwoByteResource(const char* data, size_t length)
+  SerializerTwoByteResource(const char* data, size_t length)
       : data_(AsciiToTwoByteString(data)), length_(length) {}
-  ~TwoByteResource() { DeleteArray<const uint16_t>(data_); }
+  ~SerializerTwoByteResource() { DeleteArray<const uint16_t>(data_); }
 
   virtual const uint16_t* data() const { return data_; }
   virtual size_t length() const { return length_; }
 
  private:
   const uint16_t* data_;
   size_t length_;
 };
 
 
 TEST(SerializeToplevelExternalString) {
   FLAG_serialize_toplevel = true;
   LocalContext context;
   Isolate* isolate = CcTest::i_isolate();
   isolate->compilation_cache()->Disable();  // Disable same-isolate code cache.
 
   v8::HandleScope scope(CcTest::isolate());
 
   // Obtain external internalized one-byte string.
-  OneByteResource one_byte_resource("one_byte", 8);
+  SerializerOneByteResource one_byte_resource("one_byte", 8);
   Handle<String> one_byte_string =
       isolate->factory()->NewStringFromAsciiChecked("one_byte");
   one_byte_string = isolate->factory()->InternalizeString(one_byte_string);
   one_byte_string->MakeExternal(&one_byte_resource);
   CHECK(one_byte_string->IsExternalOneByteString());
   CHECK(one_byte_string->IsInternalizedString());
 
   // Obtain external internalized two-byte string.
-  TwoByteResource two_byte_resource("two_byte", 8);
+  SerializerTwoByteResource two_byte_resource("two_byte", 8);
   Handle<String> two_byte_string =
       isolate->factory()->NewStringFromAsciiChecked("two_byte");
   two_byte_string = isolate->factory()->InternalizeString(two_byte_string);
   two_byte_string->MakeExternal(&two_byte_resource);
   CHECK(two_byte_string->IsExternalTwoByteString());
   CHECK(two_byte_string->IsInternalizedString());
 
   const char* source =
       "var o = {}               \n"
       "o.one_byte = 7;          \n"
@@ skipping 42 matching lines @@
 
   Factory* f = isolate->factory();
 
   v8::HandleScope scope(CcTest::isolate());
 
   // Create a huge external internalized string to use as variable name.
   Vector<const uint8_t> string =
       ConstructSource(STATIC_CHAR_VECTOR(""), STATIC_CHAR_VECTOR("abcdef"),
                       STATIC_CHAR_VECTOR(""), 1000000);
   Handle<String> name = f->NewStringFromOneByte(string).ToHandleChecked();
-  OneByteResource one_byte_resource(
+  SerializerOneByteResource one_byte_resource(
       reinterpret_cast<const char*>(string.start()), string.length());
   name = f->InternalizeString(name);
   name->MakeExternal(&one_byte_resource);
   CHECK(name->IsExternalOneByteString());
   CHECK(name->IsInternalizedString());
   CHECK(isolate->heap()->InSpace(*name, LO_SPACE));
 
   // Create the source, which is "var <literal> = 42; <literal>".
   Handle<String> source_str =
       f->NewConsString(
@@ skipping 78 matching lines @@
     {
       DisallowCompilation no_compile(reinterpret_cast<Isolate*>(isolate2));
       script = v8::ScriptCompiler::CompileUnbound(
           isolate2, &source, v8::ScriptCompiler::kConsumeCodeCache);
     }
     v8::Local<v8::Value> result = script->BindToCurrentContext()->Run();
     CHECK(result->ToString()->Equals(v8_str("abcdef")));
   }
   isolate2->Dispose();
 }