[tracing] Optimize StackFrameDeduplicator.

base/trace_event/heap_profiler_stack_frame_deduplicator_unittest.cc

 // 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.
 
 #include "base/trace_event/heap_profiler_stack_frame_deduplicator.h"
 
 #include <iterator>
 #include <memory>
 
 #include "base/macros.h"
@@ skipping 88 matching lines @@
   StackFrame null_bt[] = {kNull};
 
   // Empty backtraces (begin == end) are mapped to an implicitly added
   // node #0. However, backtrace with a single null frame is not empty,
   // and should be mapped to some other id.
 
   StringDeduplicator string_dedup;
   StackFrameDeduplicator dedup(&string_dedup);
 
   // Node #0 is added implicitly and corresponds to an empty backtrace.
-  ASSERT_EQ(dedup.begin() + 1, dedup.end());
+  ASSERT_TRUE(dedup.begin() + 1 == dedup.end());
   ASSERT_EQ(0, dedup.Insert(std::begin(null_bt), std::begin(null_bt)));
 
   // Placeholder entry for ID 0 is a frame with NULL name and no parent.
   // However inserting such a frame should yield a different ID.
   ExpectIncrementalEntries(&dedup, &string_dedup, {{0, kNull}});
   ASSERT_EQ(1, dedup.Insert(std::begin(null_bt), std::end(null_bt)));
 }
 
 TEST(StackFrameDeduplicatorTest, SingleBacktrace) {
   StackFrame bt[] = {kBrowserMain, kCreateWidget, kMalloc};
@@ skipping 11 matching lines @@
   auto iter = dedup.begin() + 1;  // skip implicit node #0
   ASSERT_EQ(kBrowserMain, (iter + 0)->frame);
   ASSERT_EQ(kInvalidStackFrameIndex, (iter + 0)->parent_frame_index);
 
   ASSERT_EQ(kCreateWidget, (iter + 1)->frame);
   ASSERT_EQ(1, (iter + 1)->parent_frame_index);
 
   ASSERT_EQ(kMalloc, (iter + 2)->frame);
   ASSERT_EQ(2, (iter + 2)->parent_frame_index);
 
-  ASSERT_EQ(iter + 3, dedup.end());
+  ASSERT_TRUE(iter + 3 == dedup.end());
 }
 
 TEST(StackFrameDeduplicatorTest, SingleBacktraceWithNull) {
   StackFrame null_frame = StackFrame::FromTraceEventName(nullptr);
   StackFrame bt[] = {kBrowserMain, null_frame, kMalloc};
 
   // Deduplicator doesn't care about what's inside StackFrames,
   // and handles nullptr StackFrame values as any other.
   //
   // So the call tree should look like this (index in brackets).
   //
   // BrowserMain [1]
   //   (null) [2]
   //     malloc [3]
 
   StringDeduplicator string_dedup;
   StackFrameDeduplicator dedup(&string_dedup);
   ASSERT_EQ(3, dedup.Insert(std::begin(bt), std::end(bt)));
 
   auto iter = dedup.begin() + 1;  // skip implicit node #0
   ASSERT_EQ(kBrowserMain, (iter + 0)->frame);
   ASSERT_EQ(kInvalidStackFrameIndex, (iter + 0)->parent_frame_index);
 
   ASSERT_EQ(null_frame, (iter + 1)->frame);
   ASSERT_EQ(1, (iter + 1)->parent_frame_index);
 
   ASSERT_EQ(kMalloc, (iter + 2)->frame);
   ASSERT_EQ(2, (iter + 2)->parent_frame_index);
 
-  ASSERT_EQ(iter + 3, dedup.end());
+  ASSERT_TRUE(iter + 3 == dedup.end());
 }
 
 // Test that there can be different call trees (there can be multiple bottom
 // frames). Also verify that frames with the same name but a different caller
 // are represented as distinct nodes.
 TEST(StackFrameDeduplicatorTest, MultipleRoots) {
   StackFrame bt0[] = {kBrowserMain, kCreateWidget};
   StackFrame bt1[] = {kRendererMain, kCreateWidget};
 
   // The call tree should look like this (index in brackets).
@@ skipping 17 matching lines @@
 
   ASSERT_EQ(kCreateWidget, (iter + 1)->frame);
   ASSERT_EQ(1, (iter + 1)->parent_frame_index);
 
   ASSERT_EQ(kRendererMain, (iter + 2)->frame);
   ASSERT_EQ(kInvalidStackFrameIndex, (iter + 2)->parent_frame_index);
 
   ASSERT_EQ(kCreateWidget, (iter + 3)->frame);
   ASSERT_EQ(3, (iter + 3)->parent_frame_index);
 
-  ASSERT_EQ(iter + 4, dedup.end());
+  ASSERT_TRUE(iter + 4 == dedup.end());
 }
 
 TEST(StackFrameDeduplicatorTest, Deduplication) {
   StackFrame bt0[] = {kBrowserMain, kCreateWidget};
   StackFrame bt1[] = {kBrowserMain, kInitialize};
 
   // The call tree should look like this (index in brackets).
   //
   // BrowserMain [1]
   //   CreateWidget [2]
   //   Initialize [3]
   //
   // Note that BrowserMain will be re-used.
 
   StringDeduplicator string_dedup;
   StackFrameDeduplicator dedup(&string_dedup);
   ASSERT_EQ(2, dedup.Insert(std::begin(bt0), std::end(bt0)));
   ASSERT_EQ(3, dedup.Insert(std::begin(bt1), std::end(bt1)));
 
   auto iter = dedup.begin() + 1;  // skip implicit node #0
   ASSERT_EQ(kBrowserMain, (iter + 0)->frame);
   ASSERT_EQ(kInvalidStackFrameIndex, (iter + 0)->parent_frame_index);
 
   ASSERT_EQ(kCreateWidget, (iter + 1)->frame);
   ASSERT_EQ(1, (iter + 1)->parent_frame_index);
 
   ASSERT_EQ(kInitialize, (iter + 2)->frame);
   ASSERT_EQ(1, (iter + 2)->parent_frame_index);
 
-  ASSERT_EQ(iter + 3, dedup.end());
+  ASSERT_TRUE(iter + 3 == dedup.end());
 
   // Inserting the same backtrace again should return the index of the existing
   // node.
   ASSERT_EQ(2, dedup.Insert(std::begin(bt0), std::end(bt0)));
   ASSERT_EQ(3, dedup.Insert(std::begin(bt1), std::end(bt1)));
   ASSERT_EQ(4 /* 1 implicit + 3 added */, dedup.end() - dedup.begin());
 }
 
 TEST(StackFrameDeduplicatorTest, SerializeIncrementally) {
   StringDeduplicator string_dedup;
   StackFrameDeduplicator dedup(&string_dedup);
 
   StackFrame bt0[] = {kBrowserMain, kCreateWidget};
   ASSERT_EQ(2, dedup.Insert(std::begin(bt0), std::end(bt0)));
 
   ExpectIncrementalEntries(
       &dedup, &string_dedup,
       {{0, kNull}, {1, kBrowserMain}, {2, kCreateWidget, 1}});
 
   StackFrame bt1[] = {kBrowserMain, kInitialize};
   ASSERT_EQ(3, dedup.Insert(std::begin(bt1), std::end(bt1)));
 
   ExpectIncrementalEntries(&dedup, &string_dedup, {{3, kInitialize, 1}});
 
   ExpectIncrementalEntries(&dedup, &string_dedup, {});
 }
 
 }  // namespace trace_event
 }  // namespace base