[Memory UMA] Return a memory summary struct with the ack message

base/trace_event/memory_dump_manager_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/memory_dump_manager.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
@@ skipping 98 matching lines @@
   base::WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
                             WaitableEvent::InitialState::NOT_SIGNALED);
   task_runner->PostTask(from_here, std::move(task));
   task_runner->PostTask(
       FROM_HERE, base::Bind(&WaitableEvent::Signal, base::Unretained(&event)));
   // The SequencedTaskRunner guarantees that |event| will only be signaled after
   // |task| is executed.
   event.Wait();
 }
 
+// Adapts a ProcessMemoryDumpCallback into a GlobalMemoryDumpCallback by
+// trimming off the result argument and calling the global callback.
+// TODO (fmeawad): we should keep the results for verification, but currently
+// all results are empty.
+void ProcessDumpCallbackAdapter(
+    GlobalMemoryDumpCallback callback,
+    uint64_t dump_guid,
+    bool success,
+    const base::Optional<base::trace_event::MemoryDumpCallbackResult>&) {
+  callback.Run(dump_guid, success);
+}
+
 // Testing MemoryDumpManagerDelegate which, by default, short-circuits dump
 // requests locally to the MemoryDumpManager instead of performing IPC dances.
 class MemoryDumpManagerDelegateForTesting : public MemoryDumpManagerDelegate {
  public:
   MemoryDumpManagerDelegateForTesting(bool is_coordinator)
       : is_coordinator_(is_coordinator) {
     ON_CALL(*this, RequestGlobalMemoryDump(_, _))
         .WillByDefault(Invoke(
-            this, &MemoryDumpManagerDelegateForTesting::CreateProcessDump));
+            this, &MemoryDumpManagerDelegateForTesting::CreateGlobalDump));

[Primiano Tucci (use gerrit), 2017/04/07 15:31:36]

Insrtead of defining an extra metod just to wrap the callback,  you can just do
it in a lambda here. This would avoid creating a method with a confusing name
(you call it "CreateglobalDump" but in reality calls CreateProcessDump with a
wrapped callback).
I think you can just do here:

.WillByDefault(Invoke([] const MemoryDumpRequestArgs& args, const
GlobalMemoryDumpCallback& callback) {
ProcessMemoryDumpCallback process_callback  = Bind(
Bind(&ProcessDumpCallbackAdapter, callback);
 CreateProcessDump(args, process_callback);
})

[fmeawad, 2017/04/10 20:20:19]

Done.

   }
 
   MOCK_METHOD2(RequestGlobalMemoryDump,
                void(const MemoryDumpRequestArgs& args,
-                    const MemoryDumpCallback& callback));
+                    const GlobalMemoryDumpCallback& callback));
 
   bool IsCoordinator() const override { return is_coordinator_; }
 
   // Promote the CreateProcessDump to public so it can be used by test fixtures.
   using MemoryDumpManagerDelegate::CreateProcessDump;
 
  private:
   bool is_coordinator_;
+
+  void CreateGlobalDump(const MemoryDumpRequestArgs& args,
+                        const GlobalMemoryDumpCallback& callback) {
+    ProcessMemoryDumpCallback process_callback =
+        Bind(&ProcessDumpCallbackAdapter, callback);
+    CreateProcessDump(args, process_callback);
+  }
 };
 
 class MockMemoryDumpProvider : public MemoryDumpProvider {
  public:
   MOCK_METHOD0(Destructor, void());
   MOCK_METHOD2(OnMemoryDump,
                bool(const MemoryDumpArgs& args, ProcessMemoryDump* pmd));
   MOCK_METHOD1(PollFastMemoryTotal, void(uint64_t* memory_total));
   MOCK_METHOD0(SuspendFastMemoryPolling, void());
 
@@ skipping 76 matching lines @@
   }
 
   void TearDown() override {
     MemoryDumpManager::SetInstanceForTesting(nullptr);
     delegate_ = nullptr;
     mdm_.reset();
     message_loop_.reset();
     TraceLog::DeleteForTesting();
   }
 
-  // Turns a Closure into a MemoryDumpCallback, keeping track of the callback
-  // result and taking care of posting the closure on the correct task runner.
-  void DumpCallbackAdapter(scoped_refptr<SingleThreadTaskRunner> task_runner,
-                           Closure closure,
-                           uint64_t dump_guid,
-                           bool success) {
+  // Turns a Closure into a GlobalMemoryDumpCallback, keeping track of the
+  // callback result and taking care of posting the closure on the correct task
+  // runner.
+  void GlobalDumpCallbackAdapter(
+      scoped_refptr<SingleThreadTaskRunner> task_runner,
+      Closure closure,
+      uint64_t dump_guid,
+      bool success) {
     last_callback_success_ = success;
     task_runner->PostTask(FROM_HERE, closure);
   }
 
   void PollFastMemoryTotal(uint64_t* memory_total) {
     mdm_->PollFastMemoryTotal(memory_total);
   }
 
  protected:
   void InitializeMemoryDumpManager(bool is_coordinator) {
     mdm_->set_dumper_registrations_ignored_for_testing(true);
     delegate_ = new MemoryDumpManagerDelegateForTesting(is_coordinator);
     mdm_->Initialize(base::WrapUnique(delegate_));
   }
 
   void RequestGlobalDumpAndWait(MemoryDumpType dump_type,
                                 MemoryDumpLevelOfDetail level_of_detail) {
     RunLoop run_loop;
-    MemoryDumpCallback callback =
-        Bind(&MemoryDumpManagerTest::DumpCallbackAdapter, Unretained(this),
-             ThreadTaskRunnerHandle::Get(), run_loop.QuitClosure());
+    GlobalMemoryDumpCallback callback = Bind(
+        &MemoryDumpManagerTest::GlobalDumpCallbackAdapter, Unretained(this),
+        ThreadTaskRunnerHandle::Get(), run_loop.QuitClosure());
     mdm_->RequestGlobalDump(dump_type, level_of_detail, callback);
     run_loop.Run();
   }
 
   void EnableTracingWithLegacyCategories(const char* category) {
     TraceLog::GetInstance()->SetEnabled(TraceConfig(category, ""),
                                         TraceLog::RECORDING_MODE);
   }
 
   void EnableTracingWithTraceConfig(const std::string& trace_config) {
@@ skipping 37 matching lines @@
   EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(0);
   RequestGlobalDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
                            MemoryDumpLevelOfDetail::DETAILED);
   DisableTracing();
 
   // Now repeat enabling the memory category and check that the dumper is
   // invoked this time.
   EnableTracingWithLegacyCategories(MemoryDumpManager::kTraceCategory);
   EXPECT_CALL(*delegate_, RequestGlobalMemoryDump(_, _)).Times(3);
   EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(3).WillRepeatedly(Return(true));
-  for (int i = 0; i < 3; ++i)
+  for (int i = 0; i < 3; ++i) {
     RequestGlobalDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
                              MemoryDumpLevelOfDetail::DETAILED);
+  }
   DisableTracing();
 
   mdm_->UnregisterDumpProvider(&mdp);
 
   // Finally check the unregister logic: the delegate will be invoked but not
   // the dump provider, as it has been unregistered.
   EnableTracingWithLegacyCategories(MemoryDumpManager::kTraceCategory);
   EXPECT_CALL(*delegate_, RequestGlobalMemoryDump(_, _)).Times(3);
   EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(0);
 
@@ skipping 474 matching lines @@
       .Times(Between(0, kPollsToQuit - 1))
       .WillRepeatedly(Return());
 
   MemoryDumpScheduler::SetPollingIntervalForTesting(1);
   EnableTracingWithTraceConfig(
       TraceConfigMemoryTestUtil::GetTraceConfig_PeakDetectionTrigger(3));
 
   int last_poll_to_request_dump = -2;
   EXPECT_CALL(*delegate_, RequestGlobalMemoryDump(_, _))
       .Times(testing::AtLeast(2))
-      .WillRepeatedly(Invoke([&last_poll_to_request_dump, &call_count](
-                                 const MemoryDumpRequestArgs& args,
-                                 const MemoryDumpCallback& callback) -> void {
-        // Minimum number of polls between dumps must be 3 (polling interval is
-        // 1ms).
-        EXPECT_GE(call_count - last_poll_to_request_dump, 3);
-        last_poll_to_request_dump = call_count;
-      }));
+      .WillRepeatedly(
+          Invoke([&last_poll_to_request_dump, &call_count](
+                     const MemoryDumpRequestArgs& args,
+                     const GlobalMemoryDumpCallback& callback) -> void {
+            // Minimum number of polls between dumps must be 3 (polling interval
+            // is 1ms).
+            EXPECT_GE(call_count - last_poll_to_request_dump, 3);
+            last_poll_to_request_dump = call_count;
+          }));
 
   run_loop.Run();
   DisableTracing();
   mdm_->UnregisterAndDeleteDumpProviderSoon(std::move(mdp1));
 }
 
 // If a thread (with a dump provider living on it) is torn down during a dump
 // its dump provider should be skipped but the dump itself should succeed.
 TEST_F(MemoryDumpManagerTest, TearDownThreadWhileDumping) {
   InitializeMemoryDumpManager(false /* is_coordinator */);
@@ skipping 160 matching lines @@
   const int kHeavyDumpPeriodMs = kHeavyDumpRate * kLightDumpPeriodMs;
   // The expected sequence with light=1ms, heavy=5ms is H,L,L,L,L,H,...
   testing::InSequence sequence;
   EXPECT_CALL(delegate, RequestGlobalMemoryDump(IsDetailedDump(), _));
   EXPECT_CALL(delegate, RequestGlobalMemoryDump(IsLightDump(), _))
       .Times(kHeavyDumpRate - 1);
   EXPECT_CALL(delegate, RequestGlobalMemoryDump(IsDetailedDump(), _));
   EXPECT_CALL(delegate, RequestGlobalMemoryDump(IsLightDump(), _))
       .Times(kHeavyDumpRate - 2);
   EXPECT_CALL(delegate, RequestGlobalMemoryDump(IsLightDump(), _))
-      .WillOnce(Invoke([quit_closure](const MemoryDumpRequestArgs& args,
-                                      const MemoryDumpCallback& callback) {
-        ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, quit_closure);
-      }));
+      .WillOnce(
+          Invoke([quit_closure](const MemoryDumpRequestArgs& args,
+                                const GlobalMemoryDumpCallback& callback) {
+            ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, quit_closure);
+          }));
 
   // Swallow all the final spurious calls until tracing gets disabled.
   EXPECT_CALL(delegate, RequestGlobalMemoryDump(_, _)).Times(AnyNumber());
 
   EnableTracingWithTraceConfig(
       TraceConfigMemoryTestUtil::GetTraceConfig_PeriodicTriggers(
           kLightDumpPeriodMs, kHeavyDumpPeriodMs));
   run_loop.Run();
   DisableTracing();
 }
@@ skipping 37 matching lines @@
             // MemoryDumpManager.dump_thread_ has been shut down.
             return true;
           }));
 
   // |unbound_mdp| should never be invoked because the thread for unbound dump
   // providers has been shutdown in the meanwhile.
   EXPECT_CALL(unbound_mdp, OnMemoryDump(_, _)).Times(0);
 
   last_callback_success_ = true;
   RunLoop run_loop;
-  MemoryDumpCallback callback =
-      Bind(&MemoryDumpManagerTest::DumpCallbackAdapter, Unretained(this),
+  GlobalMemoryDumpCallback callback =
+      Bind(&MemoryDumpManagerTest::GlobalDumpCallbackAdapter, Unretained(this),
            ThreadTaskRunnerHandle::Get(), run_loop.QuitClosure());
   mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
                           MemoryDumpLevelOfDetail::DETAILED, callback);
   DisableTracing();
   tracing_disabled_event.Signal();
   run_loop.Run();
 
   EXPECT_FALSE(last_callback_success_);
 }
 
@@ skipping 10 matching lines @@
 
   // Create both same-thread MDP and another MDP with dedicated thread
   MockMemoryDumpProvider mdp1;
   RegisterDumpProvider(&mdp1, nullptr);
   MockMemoryDumpProvider mdp2;
   RegisterDumpProvider(&mdp2, mdp_thread->task_runner(), kDefaultOptions);
   EnableTracingWithLegacyCategories(MemoryDumpManager::kTraceCategory);
 
   EXPECT_CALL(*delegate_, RequestGlobalMemoryDump(_, _))
       .WillOnce(Invoke([this](const MemoryDumpRequestArgs& args,
-                              const MemoryDumpCallback& callback) {
+                              const GlobalMemoryDumpCallback& callback) {
         DisableTracing();
-        delegate_->CreateProcessDump(args, callback);
+        ProcessMemoryDumpCallback process_callback =
+            Bind(&ProcessDumpCallbackAdapter, callback);
+        delegate_->CreateProcessDump(args, process_callback);
       }));
 
   // If tracing is disabled for current session CreateProcessDump() should NOT
   // request dumps from providers. Real-world regression: crbug.com/600570 .
   EXPECT_CALL(mdp1, OnMemoryDump(_, _)).Times(0);
   EXPECT_CALL(mdp2, OnMemoryDump(_, _)).Times(0);
 
   last_callback_success_ = true;
   RequestGlobalDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
                            MemoryDumpLevelOfDetail::DETAILED);
@@ skipping 146 matching lines @@
 TEST_F(MemoryDumpManagerTest, TestBackgroundTracingSetup) {
   InitializeMemoryDumpManager(true /* is_coordinator */);
 
   RunLoop run_loop;
   auto quit_closure = run_loop.QuitClosure();
 
   testing::InSequence sequence;
   EXPECT_CALL(*delegate_, RequestGlobalMemoryDump(IsBackgroundDump(), _))
       .Times(5);
   EXPECT_CALL(*delegate_, RequestGlobalMemoryDump(IsBackgroundDump(), _))
-      .WillOnce(Invoke([quit_closure](const MemoryDumpRequestArgs& args,
-                                      const MemoryDumpCallback& callback) {
-        ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, quit_closure);
-      }));
+      .WillOnce(
+          Invoke([quit_closure](const MemoryDumpRequestArgs& args,
+                                const GlobalMemoryDumpCallback& callback) {
+            ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, quit_closure);
+          }));
   EXPECT_CALL(*delegate_, RequestGlobalMemoryDump(_, _)).Times(AnyNumber());
 
   EnableTracingWithTraceConfig(
       TraceConfigMemoryTestUtil::GetTraceConfig_BackgroundTrigger(
           1 /* period_ms */));
 
   // Only background mode dumps should be allowed with the trace config.
   last_callback_success_ = false;
   RequestGlobalDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
                            MemoryDumpLevelOfDetail::LIGHT);
@@ skipping 20 matching lines @@
   thread.Start();
   RegisterDumpProvider(&mdp1, thread.task_runner(), kDefaultOptions,
                        "BlacklistTestDumpProvider");
   // Unregistering on wrong thread should not crash.
   mdm_->UnregisterDumpProvider(&mdp1);
   thread.Stop();
 }
 
 }  // namespace trace_event
 }  // namespace base