Revert "[Memory-UMA] Implement basic working prototype."

chrome/browser/metrics/process_memory_metrics_emitter_browsertest.cc

 // Copyright 2017 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/process_memory_metrics_emitter.h"
 
-#include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
-#include "base/test/histogram_tester.h"
-#include "base/test/trace_event_analyzer.h"
-#include "base/trace_event/memory_dump_manager.h"
-#include "base/trace_event/trace_config_memory_test_util.h"
 #include "chrome/test/base/in_process_browser_test.h"
-#include "chrome/test/base/tracing.h"
-#include "chrome/test/base/ui_test_utils.h"
 #include "content/public/test/test_utils.h"
-#include "url/gurl.h"
 
 namespace {
 
-using base::trace_event::MemoryDumpType;
-
-void RequestGlobalDumpCallback(base::Closure quit_closure,
-                               uint64_t,
-                               bool success) {
-  base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, quit_closure);
-  ASSERT_TRUE(success);
-}
-
-void OnStartTracingDoneCallback(
-    base::trace_event::MemoryDumpLevelOfDetail explicit_dump_type,
-    base::Closure quit_closure) {
-  base::trace_event::MemoryDumpManager::GetInstance()->RequestGlobalDump(
-      MemoryDumpType::EXPLICITLY_TRIGGERED, explicit_dump_type,
-      Bind(&RequestGlobalDumpCallback, quit_closure));
-}
-
 class ProcessMemoryMetricsEmitterFake : public ProcessMemoryMetricsEmitter {
  public:
-  explicit ProcessMemoryMetricsEmitterFake(base::RunLoop* run_loop)
-      : run_loop_(run_loop) {}
+  ProcessMemoryMetricsEmitterFake() {}
 
  private:
   ~ProcessMemoryMetricsEmitterFake() override {}
 
   void ReceivedMemoryDump(
       uint64_t dump_guid,
       bool success,
       memory_instrumentation::mojom::GlobalMemoryDumpPtr ptr) override {
     EXPECT_TRUE(success);
-    ProcessMemoryMetricsEmitter::ReceivedMemoryDump(dump_guid, success,
-                                                    std::move(ptr));
-    if (run_loop_)
-      run_loop_->Quit();
+    base::MessageLoop::current()->QuitWhenIdle();
   }
 
-  base::RunLoop* run_loop_;
-
   DISALLOW_COPY_AND_ASSIGN(ProcessMemoryMetricsEmitterFake);
 };
 
-void CheckMemoryMetric(const std::string& name,
-                       const base::HistogramTester& histogram_tester,
-                       int count,
-                       bool check_minimum) {
-  histogram_tester.ExpectTotalCount(name, count);
-  std::unique_ptr<base::HistogramSamples> samples(
-      histogram_tester.GetHistogramSamplesSinceCreation(name));
-  ASSERT_TRUE(samples);
-  if (check_minimum)
-    EXPECT_GT(samples->sum(), 0u) << name;
-
-  // As a sanity check, no memory stat should exceed 1 GB.
-  int64_t maximum_expected_size = 1ll << 30;
-  EXPECT_LT(samples->sum(), maximum_expected_size) << name;
-}
-
-void CheckAllMemoryMetrics(const base::HistogramTester& histogram_tester,
-                           int count) {
-#if (defined(OS_MACOSX) && !defined(OS_IOS)) || defined(OS_LINUX) || \
-    defined(OS_ANDROID)
-  bool private_footprint_implemented = true;
-#else
-  bool private_footprint_implemented = false;
-#endif
-
-  CheckMemoryMetric("Memory.Experimental.Browser2.Malloc", histogram_tester,
-                    count, true);
-  CheckMemoryMetric("Memory.Experimental.Browser2.Resident", histogram_tester,
-                    count, true);
-  CheckMemoryMetric("Memory.Experimental.Browser2.PrivateMemoryFootprint",
-                    histogram_tester, count, private_footprint_implemented);
-  CheckMemoryMetric("Memory.Experimental.Renderer2.Malloc", histogram_tester,
-                    count, true);
-  CheckMemoryMetric("Memory.Experimental.Renderer2.Resident", histogram_tester,
-                    count, true);
-  CheckMemoryMetric("Memory.Experimental.Renderer2.BlinkGC", histogram_tester,
-                    count, false);
-  CheckMemoryMetric("Memory.Experimental.Renderer2.PartitionAlloc",
-                    histogram_tester, count, false);
-  CheckMemoryMetric("Memory.Experimental.Renderer2.V8", histogram_tester, count,
-                    true);
-  CheckMemoryMetric("Memory.Experimental.Renderer2.PrivateMemoryFootprint",
-                    histogram_tester, count, private_footprint_implemented);
-}
-
 }  // namespace
 
 class ProcessMemoryMetricsEmitterTest : public InProcessBrowserTest {
  public:
   ProcessMemoryMetricsEmitterTest() {}
   ~ProcessMemoryMetricsEmitterTest() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ProcessMemoryMetricsEmitterTest);
 };
 
-#if defined(ADDRESS_SANITIZER)
-#define MAYBE_FetchAndEmitMetrics DISABLED_FetchAndEmitMetrics
-#else
-#define MAYBE_FetchAndEmitMetrics FetchAndEmitMetrics
-#endif
-IN_PROC_BROWSER_TEST_F(ProcessMemoryMetricsEmitterTest,
-                       MAYBE_FetchAndEmitMetrics) {
-  base::HistogramTester histogram_tester;
-  base::RunLoop run_loop;
-
+IN_PROC_BROWSER_TEST_F(ProcessMemoryMetricsEmitterTest, FetchAndEmitMetrics) {
   // Intentionally let emitter leave scope to check that it correctly keeps
   // itself alive.
   {
     scoped_refptr<ProcessMemoryMetricsEmitterFake> emitter(
-        new ProcessMemoryMetricsEmitterFake(&run_loop));
+        new ProcessMemoryMetricsEmitterFake);
     emitter->FetchAndEmitProcessMemoryMetrics();
   }
 
-  run_loop.Run();
-
-  CheckAllMemoryMetrics(histogram_tester, 1);
+  content::RunMessageLoop();
 }
-
-#if defined(ADDRESS_SANITIZER)
-#define MAYBE_FetchDuringTrace DISABLED_FetchDuringTrace
-#else
-#define MAYBE_FetchDuringTrace FetchDuringTrace
-#endif
-IN_PROC_BROWSER_TEST_F(ProcessMemoryMetricsEmitterTest,
-                       MAYBE_FetchDuringTrace) {
-  base::HistogramTester histogram_tester;
-  base::RunLoop run_loop;
-
-  base::trace_event::TraceConfig trace_config(
-      base::trace_event::TraceConfigMemoryTestUtil::
-          GetTraceConfig_EmptyTriggers());
-  ASSERT_TRUE(tracing::BeginTracingWithTraceConfig(
-      trace_config, Bind(&OnStartTracingDoneCallback,
-                         base::trace_event::MemoryDumpLevelOfDetail::DETAILED,
-                         run_loop.QuitClosure())));
-
-  // Intentionally let emitter leave scope to check that it correctly keeps
-  // itself alive.
-  {
-    scoped_refptr<ProcessMemoryMetricsEmitterFake> emitter(
-        new ProcessMemoryMetricsEmitterFake(&run_loop));
-    emitter->FetchAndEmitProcessMemoryMetrics();
-  }
-
-  GURL url1("about:blank");
-  ui_test_utils::NavigateToURLWithDisposition(
-      browser(), url1, WindowOpenDisposition::NEW_FOREGROUND_TAB,
-      ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
-  run_loop.Run();
-
-  std::string json_events;
-  ASSERT_TRUE(tracing::EndTracing(&json_events));
-
-  trace_analyzer::TraceEventVector events;
-  std::unique_ptr<trace_analyzer::TraceAnalyzer> analyzer(
-      trace_analyzer::TraceAnalyzer::Create(json_events));
-  analyzer->FindEvents(
-      trace_analyzer::Query::EventPhaseIs(TRACE_EVENT_PHASE_MEMORY_DUMP),
-      &events);
-
-  ASSERT_GT(events.size(), 1u);
-  ASSERT_TRUE(trace_analyzer::CountMatches(
-      events, trace_analyzer::Query::EventNameIs(MemoryDumpTypeToString(
-                  MemoryDumpType::EXPLICITLY_TRIGGERED))));
-
-  CheckAllMemoryMetrics(histogram_tester, 1);
-}
-
-#if defined(ADDRESS_SANITIZER)
-#define MAYBE_FetchThreeTimes DISABLED_FetchThreeTimes
-#else
-#define MAYBE_FetchThreeTimes FetchThreeTimes
-#endif
-IN_PROC_BROWSER_TEST_F(ProcessMemoryMetricsEmitterTest, MAYBE_FetchThreeTimes) {
-  base::HistogramTester histogram_tester;
-  base::RunLoop run_loop;
-
-  int count = 3;
-  for (int i = 0; i < count; ++i) {
-    // Only the last emitter should stop the run loop.
-    auto emitter = base::MakeShared<ProcessMemoryMetricsEmitterFake>(
-        (i == count - 1) ? &run_loop : nullptr);
-    emitter->FetchAndEmitProcessMemoryMetrics();
-  }
-
-  run_loop.Run();
-
-  CheckAllMemoryMetrics(histogram_tester, count);
-}