Detach LeakDetectorController from remote controller on shutdown

chrome/browser/metrics/leak_detector/leak_detector_controller_unittest.cc

 // Copyright 2016 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 "chrome/browser/metrics/leak_detector/leak_detector_controller.h"
 
 #include <set>
 
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "components/metrics/proto/memory_leak_report.pb.h"
+#include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace metrics {
 
 namespace {
 
 // Converts a vector of values into a protobuf RepeatedField. Although there is
 // no hard requirement, T should be a POD type since that is what RepeatedField
 // is used for in protobuf classes.
 template <typename T>
 void InitializeRepeatedField(const std::vector<T>& input,
                              ::google::protobuf::RepeatedField<T>* output) {
   *output = ::google::protobuf::RepeatedField<T>(input.begin(), input.end());
 }
 
 }  // namespace
 
 // Test class for LeakDetectorController that exposes protected methods.
 class TestLeakDetectorController : public LeakDetectorController {
  public:
   using LeakDetectorController::OnLeaksFound;
 
   TestLeakDetectorController() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestLeakDetectorController);
 };
 
+class LeakDetectorControllerTest : public ::testing::Test {
+ public:
+  LeakDetectorControllerTest() {}
+
+ private:
+  // For supporting content::BrowserThread operations.
+  content::TestBrowserThreadBundle thread_bundle_;
+
+  DISALLOW_COPY_AND_ASSIGN(LeakDetectorControllerTest);
+};
+
 // Use a global instance of the test class because LeakDetectorController
 // initializes class LeakDetector, which can only be initialized once, enforced
 // by an internal CHECK. Multiple initializations of LeakDetectorController in
 // the same process will result in multiple initializations of class
 // LeakDetector.
 //
 // See src/components/metrics/leak_detector/leak_detector.h for more info.
 base::LazyInstance<TestLeakDetectorController> g_instance =
     LAZY_INSTANCE_INITIALIZER;
 
-TEST(LeakDetectorControllerTest, SingleReport) {
+TEST_F(LeakDetectorControllerTest, SingleReport) {
   MemoryLeakReportProto report;
   report.set_size_bytes(8);
   InitializeRepeatedField({1, 2, 3, 4}, report.mutable_call_stack());
 
   TestLeakDetectorController* controller = &g_instance.Get();
   controller->OnLeaksFound({report});
 
   std::vector<MemoryLeakReportProto> stored_reports;
   controller->GetLeakReports(&stored_reports);
   ASSERT_EQ(1U, stored_reports.size());
@@ skipping 12 matching lines @@
   EXPECT_EQ(4U, proto.params().max_stack_depth());
   EXPECT_EQ(32U * 1024 * 1024, proto.params().analysis_interval_bytes());
   EXPECT_EQ(4U, proto.params().size_suspicion_threshold());
   EXPECT_EQ(4U, proto.params().call_stack_suspicion_threshold());
 
   // No more reports.
   controller->GetLeakReports(&stored_reports);
   ASSERT_EQ(0U, stored_reports.size());
 }
 
-TEST(LeakDetectorControllerTest, SingleReportHistory) {
+TEST_F(LeakDetectorControllerTest, SingleReportHistory) {
   MemoryLeakReportProto report;
 
   auto* entry = report.add_alloc_breakdown_history();
   InitializeRepeatedField({100, 200, 300}, entry->mutable_counts_by_size());
   entry->set_count_for_call_stack(15);
 
   entry = report.add_alloc_breakdown_history();
   InitializeRepeatedField({150, 250, 350, 650},
                           entry->mutable_counts_by_size());
   entry->set_count_for_call_stack(30);
@@ skipping 32 matching lines @@
   EXPECT_EQ(400U, history.Get(2).counts_by_size(2));
   EXPECT_EQ(700U, history.Get(2).counts_by_size(3));
   EXPECT_EQ(800U, history.Get(2).counts_by_size(4));
   EXPECT_EQ(45U, history.Get(2).count_for_call_stack());
 
   // No more reports.
   controller->GetLeakReports(&stored_reports);
   ASSERT_EQ(0U, stored_reports.size());
 }
 
-TEST(LeakDetectorControllerTest, MultipleReportsSeparately) {
+TEST_F(LeakDetectorControllerTest, MultipleReportsSeparately) {
   TestLeakDetectorController* controller = &g_instance.Get();
   std::vector<MemoryLeakReportProto> stored_reports;
 
   // Pass in first report.
   MemoryLeakReportProto report1;
   report1.set_size_bytes(8);
   InitializeRepeatedField({1, 2, 3, 4}, report1.mutable_call_stack());
 
   controller->OnLeaksFound({report1});
   controller->GetLeakReports(&stored_reports);
@@ skipping 48 matching lines @@
   EXPECT_EQ(12U, stored_reports[0].call_stack().Get(3));
   EXPECT_EQ(13U, stored_reports[0].call_stack().Get(4));
   EXPECT_EQ(14U, stored_reports[0].call_stack().Get(5));
   EXPECT_EQ(15U, stored_reports[0].call_stack().Get(6));
   EXPECT_EQ(16U, stored_reports[0].call_stack().Get(7));
 
   controller->GetLeakReports(&stored_reports);
   ASSERT_EQ(0U, stored_reports.size());
 }
 
-TEST(LeakDetectorControllerTest, MultipleReportsTogether) {
+TEST_F(LeakDetectorControllerTest, MultipleReportsTogether) {
   std::vector<MemoryLeakReportProto> reports(3);
   reports[0].set_size_bytes(8);
   InitializeRepeatedField({1, 2, 3, 4}, reports[0].mutable_call_stack());
   reports[1].set_size_bytes(16);
   InitializeRepeatedField({5, 6, 7, 8, 9, 10}, reports[1].mutable_call_stack());
   reports[2].set_size_bytes(24);
   InitializeRepeatedField({9, 10, 11, 12, 13, 14, 15, 16},
                           reports[2].mutable_call_stack());
 
   TestLeakDetectorController* controller = &g_instance.Get();
@@ skipping 29 matching lines @@
   EXPECT_EQ(13U, stored_reports[2].call_stack().Get(4));
   EXPECT_EQ(14U, stored_reports[2].call_stack().Get(5));
   EXPECT_EQ(15U, stored_reports[2].call_stack().Get(6));
   EXPECT_EQ(16U, stored_reports[2].call_stack().Get(7));
 
   controller->GetLeakReports(&stored_reports);
   ASSERT_EQ(0U, stored_reports.size());
 }
 
 }  // namespace metrics