Revert of components/metrics: Add runtime memory leak detector

components/metrics/leak_detector/leak_detector_impl_unittest.cc

Index: components/metrics/leak_detector/leak_detector_impl_unittest.cc
diff --git a/components/metrics/leak_detector/leak_detector_impl_unittest.cc b/components/metrics/leak_detector/leak_detector_impl_unittest.cc
deleted file mode 100644
index 0e9293ef83260c8dc4a6f13ee3711fa830c26e70..0000000000000000000000000000000000000000
--- a/components/metrics/leak_detector/leak_detector_impl_unittest.cc
+++ /dev/null
@@ -1,464 +0,0 @@
-// 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 "components/metrics/leak_detector/leak_detector_impl.h"
-
-#include <math.h>
-#include <stdint.h>
-
-#include <complex>
-#include <new>
-#include <set>
-#include <vector>
-
-#include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
-#include "components/metrics/leak_detector/custom_allocator.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace metrics {
-namespace leak_detector {
-
-using InternalLeakReport = LeakDetectorImpl::LeakReport;
-
-namespace {
-
-// Makes working with complex numbers easier.
-using Complex = std::complex<double>;
-
-// The mapping location in memory for a fictional executable.
-const uintptr_t kMappingAddr = 0x800000;
-const size_t kMappingSize = 0x200000;
-
-// Some call stacks within the fictional executable.
-// * - outside the mapping range, e.g. JIT code.
-const uintptr_t kRawStack0[] = {
-    0x800100, 0x900000, 0x880080, 0x810000,
-};
-const uintptr_t kRawStack1[] = {
-    0x940000, 0x980000,
-    0xdeadbeef,  // *
-    0x9a0000,
-};
-const uintptr_t kRawStack2[] = {
-    0x8f0d00, 0x803abc, 0x9100a0,
-};
-const uintptr_t kRawStack3[] = {
-    0x90fcde,
-    0x900df00d,  // *
-    0x801000,   0x880088,
-    0xdeadcafe,  // *
-    0x9f0000,   0x8700a0, 0x96037c,
-};
-const uintptr_t kRawStack4[] = {
-    0x8c0000, 0x85d00d, 0x921337,
-    0x780000,  // *
-};
-const uintptr_t kRawStack5[] = {
-    0x990000, 0x888888, 0x830ac0, 0x8e0000,
-    0xc00000,  // *
-};
-
-// This struct makes it easier to pass call stack info to
-// LeakDetectorImplTest::Alloc().
-struct TestCallStack {
-  const uintptr_t* stack;  // A reference to the original stack data.
-  size_t depth;
-};
-
-const TestCallStack kStack0 = {kRawStack0, arraysize(kRawStack0)};
-const TestCallStack kStack1 = {kRawStack1, arraysize(kRawStack1)};
-const TestCallStack kStack2 = {kRawStack2, arraysize(kRawStack2)};
-const TestCallStack kStack3 = {kRawStack3, arraysize(kRawStack3)};
-const TestCallStack kStack4 = {kRawStack4, arraysize(kRawStack4)};
-const TestCallStack kStack5 = {kRawStack5, arraysize(kRawStack5)};
-
-// The interval between consecutive analyses (LeakDetectorImpl::TestForLeaks),
-// in number of bytes allocated. e.g. if |kAllocedSizeAnalysisInterval| = 1024
-// then call TestForLeaks() every 1024 bytes of allocation that occur.
-static const size_t kAllocedSizeAnalysisInterval = 8192;
-
-}  // namespace
-
-// This test suite will test the ability of LeakDetectorImpl to catch leaks in
-// a program. Individual tests can run leaky code locally.
-//
-// The leaky code must call Alloc() and Free() for heap memory management. It
-// should not call See comments on those
-// functions for more details.
-class LeakDetectorImplTest : public ::testing::Test {
- public:
-  LeakDetectorImplTest()
-      : total_num_allocs_(0),
-        total_num_frees_(0),
-        total_alloced_size_(0),
-        next_analysis_total_alloced_size_(kAllocedSizeAnalysisInterval) {}
-
-  void SetUp() override {
-    CustomAllocator::Initialize();
-
-    const int kSizeSuspicionThreshold = 4;
-    const int kCallStackSuspicionThreshold = 4;
-    detector_.reset(new LeakDetectorImpl(kMappingAddr, kMappingSize,
-                                         kSizeSuspicionThreshold,
-                                         kCallStackSuspicionThreshold));
-  }
-
-  void TearDown() override {
-    // Free any memory that was leaked by test cases. Do not use Free() because
-    // that will try to modify |alloced_ptrs_|.
-    for (void* ptr : alloced_ptrs_)
-      delete[] reinterpret_cast<char*>(ptr);
-    alloced_ptrs_.clear();
-
-    // Must destroy all objects that use CustomAllocator before shutting down.
-    detector_.reset();
-    stored_reports_.clear();
-
-    EXPECT_TRUE(CustomAllocator::Shutdown());
-  }
-
- protected:
-  // Alloc and free functions that allocate and free heap memory and
-  // automatically pass alloc/free info to |detector_|. They emulate the
-  // alloc/free hook functions that would call into LeakDetectorImpl in
-  // real-life usage. They also keep track of individual allocations locally, so
-  // any leaked memory could be cleaned up.
-  //
-  // |stack| is just a nominal call stack object to identify the call site. It
-  // doesn't have to contain the stack trace of the actual call stack.
-  void* Alloc(size_t size, const TestCallStack& stack) {
-    void* ptr = new char[size];
-    detector_->RecordAlloc(ptr, size, stack.depth,
-                           reinterpret_cast<const void* const*>(stack.stack));
-
-    EXPECT_TRUE(alloced_ptrs_.find(ptr) == alloced_ptrs_.end());
-    alloced_ptrs_.insert(ptr);
-
-    ++total_num_allocs_;
-    total_alloced_size_ += size;
-    if (total_alloced_size_ >= next_analysis_total_alloced_size_) {
-      LeakDetectorImpl::InternalVector<InternalLeakReport> reports;
-      detector_->TestForLeaks(&reports);
-      for (const InternalLeakReport& report : reports)
-        stored_reports_.insert(report);
-
-      // Determine when the next leak analysis should occur.
-      while (total_alloced_size_ >= next_analysis_total_alloced_size_)
-        next_analysis_total_alloced_size_ += kAllocedSizeAnalysisInterval;
-    }
-    return ptr;
-  }
-
-  // See comment for Alloc().
-  void Free(void* ptr) {
-    auto find_ptr_iter = alloced_ptrs_.find(ptr);
-    EXPECT_FALSE(find_ptr_iter == alloced_ptrs_.end());
-    if (find_ptr_iter == alloced_ptrs_.end())
-      return;
-    alloced_ptrs_.erase(find_ptr_iter);
-    ++total_num_frees_;
-
-    detector_->RecordFree(ptr);
-
-    delete[] reinterpret_cast<char*>(ptr);
-  }
-
-  // TEST CASE: Julia set fractal computation. Pass in enable_leaks=true to
-  // trigger some memory leaks.
-  void JuliaSet(bool enable_leaks);
-
-  // Instance of the class being tested.
-  scoped_ptr<LeakDetectorImpl> detector_;
-
-  // Number of pointers allocated and freed so far.
-  size_t total_num_allocs_;
-  size_t total_num_frees_;
-
-  // Keeps count of total size allocated by Alloc().
-  size_t total_alloced_size_;
-
-  // The cumulative allocation size at which to trigger the TestForLeaks() call.
-  size_t next_analysis_total_alloced_size_;
-
-  // Stores all pointers to memory allocated by by Alloc() so we can manually
-  // free the leaked pointers at the end. This also serves as redundant
-  // bookkeepping: it stores all pointers that have been allocated but not yet
-  // freed.
-  std::set<void*> alloced_ptrs_;
-
-  // Store leak reports here. Use a set so duplicate reports are not stored.
-  std::set<InternalLeakReport> stored_reports_;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(LeakDetectorImplTest);
-};
-
-void LeakDetectorImplTest::JuliaSet(bool enable_leaks) {
-  // The center region of the complex plane that is the basis for our Julia set
-  // computations is a circle of radius kRadius.
-  constexpr double kRadius = 2;
-
-  // To track points in the complex plane, we will use a rectangular grid in the
-  // range defined by [-kRadius, kRadius] along both axes.
-  constexpr double kRangeMin = -kRadius;
-  constexpr double kRangeMax = kRadius;
-
-  // Divide each axis into intervals, each of which is associated with a point
-  // on that axis at its center.
-  constexpr double kIntervalInverse = 64;
-  constexpr double kInterval = 1.0 / kIntervalInverse;
-  constexpr int kNumPoints = (kRangeMax - kRangeMin) / kInterval + 1;
-
-  // Contains some useful functions for converting between points on the complex
-  // plane and in a gridlike data structure.
-  struct ComplexPlane {
-    static int GetXGridIndex(const Complex& value) {
-      return (value.real() + kInterval / 2 - kRangeMin) / kInterval;
-    }
-    static int GetYGridIndex(const Complex& value) {
-      return (value.imag() + kInterval / 2 - kRangeMin) / kInterval;
-    }
-    static int GetArrayIndex(const Complex& value) {
-      return GetXGridIndex(value) + GetYGridIndex(value) * kNumPoints;
-    }
-    static Complex GetComplexForGridPoint(size_t x, size_t y) {
-      return Complex(kRangeMin + x * kInterval, kRangeMin + y * kInterval);
-    }
-  };
-
-  // Make sure the choice of interval doesn't result in any loss of precision.
-  ASSERT_EQ(1.0, kInterval * kIntervalInverse);
-
-  // Create a grid for part of the complex plane, with each axis within the
-  // range [kRangeMin, kRangeMax].
-  constexpr size_t width = kNumPoints;
-  constexpr size_t height = kNumPoints;
-  std::vector<Complex*> grid(width * height);
-
-  // Initialize an object for each point within the inner circle |z| < kRadius.
-  for (size_t i = 0; i < width; ++i) {
-    for (size_t j = 0; j < height; ++j) {
-      Complex point = ComplexPlane::GetComplexForGridPoint(i, j);
-      // Do not store any values outside the inner circle.
-      if (abs(point) <= kRadius) {
-        grid[i + j * width] =
-            new (Alloc(sizeof(Complex), kStack0)) Complex(point);
-      }
-    }
-  }
-  EXPECT_LE(alloced_ptrs_.size(), width * height);
-
-  // Create a new grid for the result of the transformation.
-  std::vector<Complex*> next_grid(width * height, nullptr);
-
-  const int kNumIterations = 20;
-  for (int n = 0; n < kNumIterations; ++n) {
-    for (int i = 0; i < kNumPoints; ++i) {
-      for (int j = 0; j < kNumPoints; ++j) {
-        if (!grid[i + j * width])
-          continue;
-
-        // NOTE: The below code is NOT an efficient way to compute a Julia set.
-        // This is only to test the leak detector with some nontrivial code.
-
-        // A simple polynomial function for generating Julia sets is:
-        //   f(z) = z^n + c
-
-        // But in this algorithm, we need the inverse:
-        //   fInv(z) = (z - c)^(1/n)
-
-        // Here, let's use n=5 and c=0.544.
-        const Complex c(0.544, 0);
-        const Complex& z = *grid[i + j * width];
-
-        // This is the principal root.
-        Complex root = pow(z - c, 0.2);
-
-        // Discard the result if it is too far out from the center of the plane.
-        if (abs(root) > kRadius)
-          continue;
-
-        // The below code only allocates Complex objects of the same size. The
-        // leak detector expects various sizes, so increase the allocation size
-        // by a different amount at each call site.
-
-        // Nth root produces N results.
-        // Place all root results on |next_grid|.
-
-        // First, place the principal root.
-        if (!next_grid[ComplexPlane::GetArrayIndex(root)]) {
-          next_grid[ComplexPlane::GetArrayIndex(root)] =
-              new (Alloc(sizeof(Complex) + 24, kStack1)) Complex(root);
-        }
-
-        double magnitude = abs(root);
-        double angle = arg(root);
-        // To generate other roots, rotate the principal root by increments of
-        // 1/N of a full circle.
-        const double kAngleIncrement = M_PI * 2 / 5;
-
-        // Second root.
-        root = std::polar(magnitude, angle + kAngleIncrement);
-        if (!next_grid[ComplexPlane::GetArrayIndex(root)]) {
-          next_grid[ComplexPlane::GetArrayIndex(root)] =
-              new (Alloc(sizeof(Complex) + 40, kStack2)) Complex(root);
-        }
-
-        // In some of the sections below, setting |enable_leaks| to true will
-        // trigger a memory leak by overwriting the old Complex pointer value
-        // without freeing it. Due to the nature of complex roots being confined
-        // to equal sections of the complex plane, each new pointer will
-        // displace an old pointer that was allocated from the same line of
-        // code.
-
-        // Third root.
-        root = std::polar(magnitude, angle + kAngleIncrement * 2);
-        // *** LEAK ***
-        if (enable_leaks || !next_grid[ComplexPlane::GetArrayIndex(root)]) {
-          next_grid[ComplexPlane::GetArrayIndex(root)] =
-              new (Alloc(sizeof(Complex) + 40, kStack3)) Complex(root);
-        }
-
-        // Fourth root.
-        root = std::polar(magnitude, angle + kAngleIncrement * 3);
-        // *** LEAK ***
-        if (enable_leaks || !next_grid[ComplexPlane::GetArrayIndex(root)]) {
-          next_grid[ComplexPlane::GetArrayIndex(root)] =
-              new (Alloc(sizeof(Complex) + 52, kStack4)) Complex(root);
-        }
-
-        // Fifth root.
-        root = std::polar(magnitude, angle + kAngleIncrement * 4);
-        if (!next_grid[ComplexPlane::GetArrayIndex(root)]) {
-          next_grid[ComplexPlane::GetArrayIndex(root)] =
-              new (Alloc(sizeof(Complex) + 52, kStack5)) Complex(root);
-        }
-      }
-    }
-
-    // Clear the previously allocated points.
-    for (Complex*& point : grid) {
-      if (point) {
-        Free(point);
-        point = nullptr;
-      }
-    }
-
-    // Now swap the two grids for the next iteration.
-    grid.swap(next_grid);
-  }
-
-  // Clear the previously allocated points.
-  for (Complex*& point : grid) {
-    if (point) {
-      Free(point);
-      point = nullptr;
-    }
-  }
-}
-
-TEST_F(LeakDetectorImplTest, CheckTestFramework) {
-  EXPECT_EQ(0U, total_num_allocs_);
-  EXPECT_EQ(0U, total_num_frees_);
-  EXPECT_EQ(0U, alloced_ptrs_.size());
-
-  // Allocate some memory.
-  void* ptr0 = Alloc(12, kStack0);
-  void* ptr1 = Alloc(16, kStack0);
-  void* ptr2 = Alloc(24, kStack0);
-  EXPECT_EQ(3U, total_num_allocs_);
-  EXPECT_EQ(0U, total_num_frees_);
-  EXPECT_EQ(3U, alloced_ptrs_.size());
-
-  // Free one of the pointers.
-  Free(ptr1);
-  EXPECT_EQ(3U, total_num_allocs_);
-  EXPECT_EQ(1U, total_num_frees_);
-  EXPECT_EQ(2U, alloced_ptrs_.size());
-
-  // Allocate some more memory.
-  void* ptr3 = Alloc(72, kStack1);
-  void* ptr4 = Alloc(104, kStack1);
-  void* ptr5 = Alloc(96, kStack1);
-  void* ptr6 = Alloc(24, kStack1);
-  EXPECT_EQ(7U, total_num_allocs_);
-  EXPECT_EQ(1U, total_num_frees_);
-  EXPECT_EQ(6U, alloced_ptrs_.size());
-
-  // Free more pointers.
-  Free(ptr2);
-  Free(ptr4);
-  Free(ptr6);
-  EXPECT_EQ(7U, total_num_allocs_);
-  EXPECT_EQ(4U, total_num_frees_);
-  EXPECT_EQ(3U, alloced_ptrs_.size());
-
-  // Free remaining memory.
-  Free(ptr0);
-  Free(ptr3);
-  Free(ptr5);
-  EXPECT_EQ(7U, total_num_allocs_);
-  EXPECT_EQ(7U, total_num_frees_);
-  EXPECT_EQ(0U, alloced_ptrs_.size());
-}
-
-TEST_F(LeakDetectorImplTest, JuliaSetNoLeak) {
-  JuliaSet(false /* enable_leaks */);
-
-  // JuliaSet() should have run cleanly without leaking.
-  EXPECT_EQ(total_num_allocs_, total_num_frees_);
-  EXPECT_EQ(0U, alloced_ptrs_.size());
-  ASSERT_EQ(0U, stored_reports_.size());
-}
-
-TEST_F(LeakDetectorImplTest, JuliaSetWithLeak) {
-  JuliaSet(true /* enable_leaks */);
-
-  // JuliaSet() should have leaked some memory from two call sites.
-  EXPECT_GT(total_num_allocs_, total_num_frees_);
-  EXPECT_GT(alloced_ptrs_.size(), 0U);
-
-  // There should be one unique leak report generated for each leaky call site.
-  ASSERT_EQ(2U, stored_reports_.size());
-
-  // The reports should be stored in order of size.
-
-  // |report1| comes from the call site in JuliaSet() corresponding to
-  // |kStack3|.
-  const InternalLeakReport& report1 = *stored_reports_.begin();
-  EXPECT_EQ(sizeof(Complex) + 40, report1.alloc_size_bytes());
-  EXPECT_EQ(kStack3.depth, report1.call_stack().size());
-  for (size_t i = 0; i < kStack3.depth && i < report1.call_stack().size();
-       ++i) {
-    // The call stack's addresses may not fall within the mapping address.
-    // Those that don't will not be converted to mapping offsets.
-    if (kStack3.stack[i] >= kMappingAddr &&
-        kStack3.stack[i] <= kMappingAddr + kMappingSize) {
-      EXPECT_EQ(kStack3.stack[i] - kMappingAddr, report1.call_stack()[i]);
-    } else {
-      EXPECT_EQ(kStack3.stack[i], report1.call_stack()[i]);
-    }
-  }
-
-  // |report2| comes from the call site in JuliaSet() corresponding to
-  // |kStack4|.
-  const InternalLeakReport& report2 = *(++stored_reports_.begin());
-  EXPECT_EQ(sizeof(Complex) + 52, report2.alloc_size_bytes());
-  EXPECT_EQ(kStack4.depth, report2.call_stack().size());
-  for (size_t i = 0; i < kStack4.depth && i < report2.call_stack().size();
-       ++i) {
-    // The call stack's addresses may not fall within the mapping address.
-    // Those that don't will not be converted to mapping offsets.
-    if (kStack4.stack[i] >= kMappingAddr &&
-        kStack4.stack[i] <= kMappingAddr + kMappingSize) {
-      EXPECT_EQ(kStack4.stack[i] - kMappingAddr, report2.call_stack()[i]);
-    } else {
-      EXPECT_EQ(kStack4.stack[i], report2.call_stack()[i]);
-    }
-  }
-}
-
-}  // namespace leak_detector
-}  // namespace metrics