[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/message_loop/message_loop.h"
+#include "base/test/histogram_tester.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:
-  ProcessMemoryMetricsEmitterFake() {}
+  explicit ProcessMemoryMetricsEmitterFake(base::RunLoop* run_loop)
+      : run_loop_(run_loop) {}
 
  private:
   ~ProcessMemoryMetricsEmitterFake() override {}
 
   void ReceivedMemoryDump(
       uint64_t dump_guid,
       bool success,
       memory_instrumentation::mojom::GlobalMemoryDumpPtr ptr) override {
     EXPECT_TRUE(success);
-    base::MessageLoop::current()->QuitWhenIdle();
+    ProcessMemoryMetricsEmitter::ReceivedMemoryDump(dump_guid, success,
+                                                    std::move(ptr));
+    if (run_loop_)
+      run_loop_->Quit();
   }
 
+  base::RunLoop* run_loop_;
+
   DISALLOW_COPY_AND_ASSIGN(ProcessMemoryMetricsEmitterFake);
 };
 
+void CheckMemoryMetric(const std::string& name,
+                       const base::HistogramTester& histogram_tester,
+                       int count) {
+  histogram_tester.ExpectTotalCount(name, count);
+  std::unique_ptr<base::HistogramSamples> samples(
+      histogram_tester.GetHistogramSamplesSinceCreation(name));
+  ASSERT_TRUE(samples);
+  EXPECT_GT(samples->sum(), 0u) << name;
+
+  // As a sanity check, no memory stat should exceed 1 GB.
+  int64_t maximum_expected_size = 1ll << 30 * count;
+  EXPECT_LT(samples->sum(), maximum_expected_size) << name;
+}
+
+void CheckAllMemoryMetrics(const base::HistogramTester& histogram_tester,
+                           int count) {
+  CheckMemoryMetric("Memory.Experimental.Browser2.Malloc", histogram_tester,
+                    count);
+  CheckMemoryMetric("Memory.Experimental.Browser2.Resident", histogram_tester,
+                    count);
+  CheckMemoryMetric("Memory.Experimental.Renderer2.Malloc", histogram_tester,
+                    count);
+  CheckMemoryMetric("Memory.Experimental.Renderer2.Resident", histogram_tester,
+                    count);
+  CheckMemoryMetric("Memory.Experimental.Renderer2.BlinkGC", histogram_tester,
+                    count);
+  CheckMemoryMetric("Memory.Experimental.Renderer2.V8", histogram_tester,
+                    count);
+}
+
 }  // namespace
 
 class ProcessMemoryMetricsEmitterTest : public InProcessBrowserTest {
  public:
   ProcessMemoryMetricsEmitterTest() {}
   ~ProcessMemoryMetricsEmitterTest() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ProcessMemoryMetricsEmitterTest);
 };
 
 IN_PROC_BROWSER_TEST_F(ProcessMemoryMetricsEmitterTest, FetchAndEmitMetrics) {
+  base::HistogramTester histogram_tester;
+  base::RunLoop run_loop;
+
   // Intentionally let emitter leave scope to check that it correctly keeps
   // itself alive.
   {
     scoped_refptr<ProcessMemoryMetricsEmitterFake> emitter(
-        new ProcessMemoryMetricsEmitterFake);
+        new ProcessMemoryMetricsEmitterFake(&run_loop));
     emitter->FetchAndEmitProcessMemoryMetrics();
   }
 
-  content::RunMessageLoop();
+  run_loop.Run();
+
+  CheckAllMemoryMetrics(histogram_tester, 1);
 }
+
+IN_PROC_BROWSER_TEST_F(ProcessMemoryMetricsEmitterTest, 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));
+  EXPECT_NE(0u, json_events.length());
+
+  CheckAllMemoryMetrics(histogram_tester, 1);
+}
+
+IN_PROC_BROWSER_TEST_F(ProcessMemoryMetricsEmitterTest, 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.
+    scoped_refptr<ProcessMemoryMetricsEmitterFake> emitter(

[dcheng, 2017/05/13 20:22:37]

auto emitter = base::MakeShared<ProcessMemoryMetricsEmitterFake>(...)

[erikchen, 2017/05/14 04:49:16]

Done.

+        new ProcessMemoryMetricsEmitterFake((i == count - 1) ? &run_loop
+                                                             : nullptr));
+    emitter->FetchAndEmitProcessMemoryMetrics();
+  }
+
+  run_loop.Run();
+
+  CheckAllMemoryMetrics(histogram_tester, count);
+}