Allow self_size to be larger than 2GB in heap snapshots.

test/cctest/test-heap-profiler.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 216 matching lines @@
       GetProperty(global, v8::HeapGraphEdge::kProperty, "x");
   CHECK_NE(NULL, x);
   const v8::HeapGraphNode* x1 =
       GetProperty(x, v8::HeapGraphEdge::kProperty, "a");
   CHECK_NE(NULL, x1);
   const v8::HeapGraphNode* x2 =
       GetProperty(x, v8::HeapGraphEdge::kProperty, "b");
   CHECK_NE(NULL, x2);
 
   // Test sizes.
-  CHECK_NE(0, x->GetSelfSize());
-  CHECK_NE(0, x1->GetSelfSize());
-  CHECK_NE(0, x2->GetSelfSize());
+  CHECK_NE(0, static_cast<int>(x->GetShallowSize()));
+  CHECK_NE(0, static_cast<int>(x1->GetShallowSize()));
+  CHECK_NE(0, static_cast<int>(x2->GetShallowSize()));
 }
 
 
 TEST(BoundFunctionInSnapshot) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
   CompileRun(
       "function myFunction(a, b) { this.a = a; this.b = b; }\n"
       "function AAAAA() {}\n"
@@ skipping 1810 matching lines @@
   const v8::HeapGraphNode* transition_info =
       GetProperty(allocation_site, v8::HeapGraphEdge::kInternal,
                   "transition_info");
   CHECK_NE(NULL, transition_info);
 
   const v8::HeapGraphNode* elements =
       GetProperty(transition_info, v8::HeapGraphEdge::kInternal,
                   "elements");
   CHECK_NE(NULL, elements);
   CHECK_EQ(v8::HeapGraphNode::kArray, elements->GetType());
-  CHECK_EQ(v8::internal::FixedArray::SizeFor(3), elements->GetSelfSize());
+  CHECK_EQ(v8::internal::FixedArray::SizeFor(3),
+           static_cast<int>(elements->GetShallowSize()));
 
   v8::Handle<v8::Value> array_val =
       heap_profiler->FindObjectById(transition_info->GetId());
   CHECK(array_val->IsArray());
   v8::Handle<v8::Array> array = v8::Handle<v8::Array>::Cast(array_val);
   // Verify the array is "a" in the code above.
   CHECK_EQ(3, array->Length());
   CHECK_EQ(v8::Integer::New(isolate, 3),
            array->Get(v8::Integer::New(isolate, 0)));
   CHECK_EQ(v8::Integer::New(isolate, 2),
@@ skipping 296 matching lines @@
   CHECK_NE(NULL, arr1_obj);
   const v8::HeapGraphNode* arr1_buffer =
       GetProperty(arr1_obj, v8::HeapGraphEdge::kInternal, "buffer");
   CHECK_NE(NULL, arr1_buffer);
   const v8::HeapGraphNode* first_view =
       GetProperty(arr1_buffer, v8::HeapGraphEdge::kWeak, "weak_first_view");
   CHECK_NE(NULL, first_view);
   const v8::HeapGraphNode* backing_store =
       GetProperty(arr1_buffer, v8::HeapGraphEdge::kInternal, "backing_store");
   CHECK_NE(NULL, backing_store);
-  CHECK_EQ(400, backing_store->GetSelfSize());
+  CHECK_EQ(400, static_cast<int>(backing_store->GetShallowSize()));
 }
 
 
 static int GetRetainersCount(const v8::HeapSnapshot* snapshot,
                              const v8::HeapGraphNode* node) {
   int count = 0;
   for (int i = 0, l = snapshot->GetNodesCount(); i < l; ++i) {
     const v8::HeapGraphNode* parent = snapshot->GetNode(i);
     for (int j = 0, l2 = parent->GetChildrenCount(); j < l2; ++j) {
       if (parent->GetChild(j)->GetToNode() == node) {
@@ skipping 55 matching lines @@
   const v8::HeapGraphNode* global_node = GetGlobalObject(snapshot);
   const v8::HeapGraphNode* box_node =
       GetProperty(global_node, v8::HeapGraphEdge::kElement, "0");
   CHECK_NE(NULL, box_node);
   v8::String::Utf8Value box_node_name(box_node->GetName());
   CHECK_EQ("system / Box", *box_node_name);
   const v8::HeapGraphNode* box_value =
       GetProperty(box_node, v8::HeapGraphEdge::kInternal, "value");
   CHECK_NE(NULL, box_value);
 }