Roll base to 9e74307b276b2f9988005c0e97e85ee222586f79.

third_party/tcmalloc/chromium/src/heap-profile-table.h

 // Copyright (c) 2006, Google Inc.
 // 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
@@ skipping 22 matching lines @@
 //
 
 #ifndef BASE_HEAP_PROFILE_TABLE_H_
 #define BASE_HEAP_PROFILE_TABLE_H_
 
 #include "addressmap-inl.h"
 #include "base/basictypes.h"
 #include "base/logging.h"   // for RawFD
 #include "heap-profile-stats.h"
 
-#if defined(TYPE_PROFILING)
-#include <gperftools/type_profiler_map.h>
-#endif  // defined(TYPE_PROFILING)
-
 // Table to maintain a heap profile data inside,
 // i.e. the set of currently active heap memory allocations.
 // thread-unsafe and non-reentrant code:
 // each instance object must be used by one thread
 // at a time w/o self-recursion.
 //
 // TODO(maxim): add a unittest for this class.
 class HeapProfileTable {
  public:
 
@@ skipping 159 matching lines @@
   //   4. Perform whatever action is supposed to free the memory again. New
   //      allocations are not marked. So all allocations that are marked as
   //      "live" where created during step 2.
   //   5. Invoke DumpMarkedObjects(MARK_TWO) to get the list of allocations that
   //      were created during step 2, but survived step 4.
   //
   // Note that this functionality cannot be used if the HeapProfileTable is
   // used for leak checking (using HeapLeakChecker).
   void DumpMarkedObjects(AllocationMark mark, const char* file_name);
 
-#if defined(TYPE_PROFILING)
-  void DumpTypeStatistics(const char* file_name) const;
-#endif  // defined(TYPE_PROFILING)
-
  private:
-  friend class DeepHeapProfile;
-
   // data types ----------------------------
 
   // Hash table bucket to hold (de)allocation stats
   // for a given allocation call stack trace.
   typedef HeapProfileBucket Bucket;
 
   // Info stored in the address map
   struct AllocValue {
     // Access to the stack-trace bucket
     Bucket* bucket() const {
@@ skipping 78 matching lines @@
     MarkArgs(AllocationMark mark_arg, bool mark_all_arg)
         : mark(mark_arg),
           mark_all(mark_all_arg) {
     }
 
     AllocationMark mark;  // The mark to put on allocations.
     bool mark_all;  // True if all allocations should be marked. Otherwise just
                     // mark unmarked allocations.
   };
 
-#if defined(TYPE_PROFILING)
-  struct TypeCount {
-    TypeCount(size_t bytes_arg, unsigned int objects_arg)
-        : bytes(bytes_arg),
-          objects(objects_arg) {
-    }
-
-    size_t bytes;
-    unsigned int objects;
-  };
-#endif  // defined(TYPE_PROFILING)
-
   struct AllocationAddressIteratorArgs {
     AllocationAddressIteratorArgs(AddressIterator callback_arg, void* data_arg)
         : callback(callback_arg),
           data(data_arg) {
     }
 
     AddressIterator callback;
     void* data;
   };
 
@@ skipping 49 matching lines @@
   // Helper for DumpNonLiveProfile to do object-granularity
   // heap profile dumping. It gets passed to AllocationMap::Iterate.
   inline static void DumpNonLiveIterator(const void* ptr, AllocValue* v,
                                          const DumpArgs& args);
 
   // Helper for DumpMarkedObjects to dump all allocations with a given mark. It
   // gets passed to AllocationMap::Iterate.
   inline static void DumpMarkedIterator(const void* ptr, AllocValue* v,
                                         const DumpMarkedArgs& args);
 
-#if defined(TYPE_PROFILING)
-  inline static void TallyTypesItererator(const void* ptr,
-                                          AllocValue* value,
-                                          AddressMap<TypeCount>* type_size_map);
-
-  inline static void DumpTypesIterator(const void* ptr,
-                                       TypeCount* size,
-                                       const DumpArgs& args);
-#endif  // defined(TYPE_PROFILING)
-
   // Helper for IterateOrderedAllocContexts and FillOrderedProfile.
   // Creates a sorted list of Buckets whose length is num_buckets_.
   // The caller is responsible for deallocating the returned list.
   Bucket** MakeSortedBucketList() const;
 
   // Helper for TakeSnapshot.  Saves object to snapshot.
   static void AddToSnapshot(const void* ptr, AllocValue* v, Snapshot* s);
 
   // Arguments passed to AddIfNonLive
   struct AddNonLiveArgs {
@@ skipping 84 matching lines @@
   // Helpers for sorting and generating leak reports
   struct Entry;
   struct ReportState;
   static void ReportCallback(const void* ptr, AllocValue* v, ReportState*);
   static void ReportObject(const void* ptr, AllocValue* v, char*);
 
   DISALLOW_COPY_AND_ASSIGN(Snapshot);
 };
 
 #endif  // BASE_HEAP_PROFILE_TABLE_H_