[tracing] Optimize AllocationRegister and increase max backtrace depth.

base/trace_event/heap_profiler_allocation_context.h

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef BASE_TRACE_EVENT_HEAP_PROFILER_ALLOCATION_CONTEXT_H_
 #define BASE_TRACE_EVENT_HEAP_PROFILER_ALLOCATION_CONTEXT_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 53 matching lines @@
 bool BASE_EXPORT operator < (const StackFrame& lhs, const StackFrame& rhs);
 bool BASE_EXPORT operator == (const StackFrame& lhs, const StackFrame& rhs);
 bool BASE_EXPORT operator != (const StackFrame& lhs, const StackFrame& rhs);
 
 struct BASE_EXPORT Backtrace {
   Backtrace();
 
   // If the stack is higher than what can be stored here, the bottom frames
   // (the ones closer to main()) are stored. Depth of 12 is enough for most
   // pseudo traces (see above), but not for native traces, where we need more.
-  enum { kMaxFrameCount = 24 };
+  enum { kMaxFrameCount = 48 };
   StackFrame frames[kMaxFrameCount];
   size_t frame_count;
 };
 
 bool BASE_EXPORT operator==(const Backtrace& lhs, const Backtrace& rhs);
+bool BASE_EXPORT operator!=(const Backtrace& lhs, const Backtrace& rhs);
 
 // The |AllocationContext| is context metadata that is kept for every allocation
 // when heap profiling is enabled. To simplify memory management for book-
 // keeping, this struct has a fixed size.
 struct BASE_EXPORT AllocationContext {
   AllocationContext();
+  AllocationContext(const Backtrace& backtrace, const char* type_name);
 
   Backtrace backtrace;
 
   // Type name of the type stored in the allocated memory. A null pointer
   // indicates "unknown type". Grouping is done by comparing pointers, not by
   // deep string comparison. In a component build, where a type name can have a
   // string literal in several dynamic libraries, this may distort grouping.
   const char* type_name;
 };
 
 bool BASE_EXPORT operator==(const AllocationContext& lhs,
                             const AllocationContext& rhs);
+bool BASE_EXPORT operator!=(const AllocationContext& lhs,
+                            const AllocationContext& rhs);
 
 // Struct to store the size and count of the allocations.
 struct AllocationMetrics {
   size_t size;
   size_t count;
 };
 
 }  // namespace trace_event
 }  // namespace base
 
@@ skipping 10 matching lines @@
 };
 
 template <>
 struct BASE_EXPORT hash<base::trace_event::AllocationContext> {
   size_t operator()(const base::trace_event::AllocationContext& context) const;
 };
 
 }  // BASE_HASH_NAMESPACE
 
 #endif  // BASE_TRACE_EVENT_HEAP_PROFILER_ALLOCATION_CONTEXT_H_