Count external string resources that were assigned to symbol strings.

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 14798 matching lines @@
   CHECK_EQ(static_cast<int>(heap_statistics.total_heap_size()), 0);
   CHECK_EQ(static_cast<int>(heap_statistics.used_heap_size()), 0);
   v8::V8::GetHeapStatistics(&heap_statistics);
   CHECK_NE(static_cast<int>(heap_statistics.total_heap_size()), 0);
   CHECK_NE(static_cast<int>(heap_statistics.used_heap_size()), 0);
 }
 
 
 class VisitorImpl : public v8::ExternalResourceVisitor {
  public:
-  VisitorImpl(TestResource* r1, TestResource* r2)
+  VisitorImpl(TestResource* r1, TestResource* r2, TestResource* r3)
       : resource1_(r1),
         resource2_(r2),
+        resource3_(r3),
         found_resource1_(false),
-        found_resource2_(false) {}
+        found_resource2_(false),
+        found_resource3_(false) {}
   virtual ~VisitorImpl() {}
   virtual void VisitExternalString(v8::Handle<v8::String> string) {
     if (!string->IsExternal()) {
       CHECK(string->IsExternalAscii());
       return;
     }
     v8::String::ExternalStringResource* resource =
         string->GetExternalStringResource();
     CHECK(resource);
     if (resource1_ == resource) {
       CHECK(!found_resource1_);
       found_resource1_ = true;
     }
     if (resource2_ == resource) {
       CHECK(!found_resource2_);
       found_resource2_ = true;
     }
+    if (resource3_ == resource) {
+      CHECK(!found_resource3_);
+      found_resource3_ = true;
+    }
   }
   void CheckVisitedResources() {
     CHECK(found_resource1_);
     CHECK(found_resource2_);
+    CHECK(found_resource3_);
   }
 
  private:
   v8::String::ExternalStringResource* resource1_;
   v8::String::ExternalStringResource* resource2_;
+  v8::String::ExternalStringResource* resource3_;
   bool found_resource1_;
   bool found_resource2_;
+  bool found_resource3_;
 };
 
 TEST(VisitExternalStrings) {
   v8::HandleScope scope;
   LocalContext env;
   const char* string = "Some string";
   uint16_t* two_byte_string = AsciiToTwoByteString(string);
   TestResource* resource1 = new TestResource(two_byte_string);
   v8::Local<v8::String> string1 = v8::String::NewExternal(resource1);
   TestResource* resource2 = new TestResource(two_byte_string);
   v8::Local<v8::String> string2 = v8::String::NewExternal(resource2);
+  TestResource* resource3 = new TestResource(two_byte_string);
+  v8::Local<v8::String> symbol = v8::String::NewSymbol(string);
+  symbol->MakeExternal(resource3);
 
-  // We need to add usages for string1 and string2 to avoid warnings in GCC 4.7
+  // We need to add usages for string1, string2 and symbol string
+  // to avoid warnings in GCC 4.7
   CHECK(string1->IsExternal());
   CHECK(string2->IsExternal());
+  CHECK(symbol->IsExternal());
 
-  VisitorImpl visitor(resource1, resource2);
+  VisitorImpl visitor(resource1, resource2, resource3);
   v8::V8::VisitExternalResources(&visitor);
   visitor.CheckVisitedResources();
 }
 
 
 static double DoubleFromBits(uint64_t value) {
   double target;
   memcpy(&target, &value, sizeof(target));
   return target;
 }
@@ skipping 2883 matching lines @@
 
   i::Semaphore* sem_;
   volatile int sem_value_;
 };
 
 
 THREADED_TEST(SemaphoreInterruption) {
   ThreadInterruptTest().RunTest();
 }
 #endif  // WIN32