Adding V8 api to get memory statistics of spaces in V8::Heap.

include/v8.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /** \mainpage V8 API Reference Guide
  *
  * V8 is Google's open source JavaScript engine.
  *
  * This set of documents provides reference material generated from the
  * V8 header file, include/v8.h.
  *
  * For other documentation see http://code.google.com/apis/v8/
  */
 
 #ifndef V8_H_
 #define V8_H_
 
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
+#include <vector>
 
 #include "v8-version.h"
 #include "v8config.h"
 
 // We reserve the V8_* prefix for macros defined in V8 public API and
 // assume there are no name conflicts with the embedder's code.
 
 #ifdef V8_OS_WIN
 
 // Setup for Windows DLL export/import. When building the V8 DLL the
@@ skipping 39 matching lines @@
 class Boolean;
 class BooleanObject;
 class Context;
 class CpuProfiler;
 class Data;
 class Date;
 class External;
 class Function;
 class FunctionTemplate;
 class HeapProfiler;
+class HeapSpacesStatistics;
 class ImplementationUtilities;
 class Int32;
 class Integer;
 class Isolate;
 template <class T>
 class Maybe;
 class Name;
 class Number;
 class NumberObject;
 class Object;
@@ skipping 4780 matching lines @@
 
 /**
  * Collection of V8 heap information.
  *
  * Instances of this class can be passed to v8::V8::HeapStatistics to
  * get heap statistics from V8.
  */
 class V8_EXPORT HeapStatistics {
  public:
   HeapStatistics();
+  ~HeapStatistics();
+
+  class SpaceStatistics {
+   public:
+    SpaceStatistics(const char* name,
+                    size_t size,
+                    size_t used_size,
+                    size_t available_size,
+                    size_t physical_size)
+        : space_name(name),
+          space_size(size),
+          space_used_size(used_size),
+          space_avalable_size(available_size),
+          physical_space_size(physical_size) {}
+    const char* space_name;
+    size_t space_size;
+    size_t space_used_size;
+    size_t space_avalable_size;
+    size_t physical_space_size;
+  };
+
   size_t total_heap_size() { return total_heap_size_; }
   size_t total_heap_size_executable() { return total_heap_size_executable_; }
   size_t total_physical_size() { return total_physical_size_; }
   size_t used_heap_size() { return used_heap_size_; }
   size_t heap_size_limit() { return heap_size_limit_; }
 
+  std::vector<SpaceStatistics>* SpacesStatistics();
+
  private:
   size_t total_heap_size_;
   size_t total_heap_size_executable_;
   size_t total_physical_size_;
   size_t used_heap_size_;
   size_t heap_size_limit_;
+  HeapSpacesStatistics* spaces_statistics_;
 
   friend class V8;
   friend class Isolate;
 };
 
 
 class RetainedObjectInfo;
 
 
 /**
@@ skipping 3190 matching lines @@
  */
 
 
 }  // namespace v8
 
 
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_