[tracing] Simplify and improve thread-hopping logic of memory-infra

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 "base/bind_helpers.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "base/trace_event/memory_dump_provider.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
+using testing::Between;
 using testing::Invoke;
 using testing::Return;
 
 namespace base {
 namespace trace_event {
 
 // Testing MemoryDumpManagerDelegate which short-circuits dump requests locally
 // instead of performing IPC dances.
 class MemoryDumpManagerDelegateForTesting : public MemoryDumpManagerDelegate {
  public:
-  void RequestGlobalMemoryDump(
-      const base::trace_event::MemoryDumpRequestArgs& args,
-      const MemoryDumpCallback& callback) override {
+  void RequestGlobalMemoryDump(const MemoryDumpRequestArgs& args,
+                               const MemoryDumpCallback& callback) override {
     CreateProcessDump(args, callback);
   }
 
   bool IsCoordinatorProcess() const override { return false; }
 };
 
 class MemoryDumpManagerTest : public testing::Test {
  public:
   void SetUp() override {
     message_loop_.reset(new MessageLoop());
@@ skipping 33 matching lines @@
  private:
   scoped_ptr<MessageLoop> message_loop_;
   MemoryDumpManagerDelegateForTesting delegate_;
 
   // We want our singleton torn down after each test.
   ShadowingAtExitManager at_exit_manager_;
 };
 
 class MockDumpProvider : public MemoryDumpProvider {
  public:
-  MockDumpProvider() : last_session_state_(nullptr) {}
+  MockDumpProvider()
+      : dump_provider_to_register_or_unregister(nullptr),
+        last_session_state_(nullptr) {}
 
   // Ctor used by the RespectTaskRunnerAffinity test.
   explicit MockDumpProvider(
       const scoped_refptr<SingleThreadTaskRunner>& task_runner)
       : last_session_state_(nullptr), task_runner_(task_runner) {}
 
   virtual ~MockDumpProvider() {}
 
   MOCK_METHOD1(OnMemoryDump, bool(ProcessMemoryDump* pmd));
 
   // OnMemoryDump() override for the RespectTaskRunnerAffinity test.
   bool OnMemoryDump_CheckTaskRunner(ProcessMemoryDump* pmd) {
     EXPECT_TRUE(task_runner_->RunsTasksOnCurrentThread());
     return true;
   }
 
   // OnMemoryDump() override for the SharedSessionState test.
   bool OnMemoryDump_CheckSessionState(ProcessMemoryDump* pmd) {
     MemoryDumpSessionState* cur_session_state = pmd->session_state().get();
     if (last_session_state_)
       EXPECT_EQ(last_session_state_, cur_session_state);
     last_session_state_ = cur_session_state;
     return true;
   }
 
+  // OnMemoryDump() override for the RegisterDumperWhileDumping test.
+  bool OnMemoryDump_RegisterExtraDumpProvider(ProcessMemoryDump* pmd) {
+    MemoryDumpManager::GetInstance()->RegisterDumpProvider(
+        dump_provider_to_register_or_unregister);
+    return true;
+  }
+
+  // OnMemoryDump() override for the UnegisterDumperWhileDumping test.
+  bool OnMemoryDump_UnregisterDumpProvider(ProcessMemoryDump* pmd) {
+    MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
+        dump_provider_to_register_or_unregister);
+    return true;
+  }
+
+  // Used by OnMemoryDump_(Un)RegisterExtraDumpProvider.
+  MemoryDumpProvider* dump_provider_to_register_or_unregister;
+
  private:
   MemoryDumpSessionState* last_session_state_;
   scoped_refptr<SingleThreadTaskRunner> task_runner_;
 };
 
 TEST_F(MemoryDumpManagerTest, SingleDumper) {
   MockDumpProvider mdp;
   mdm_->RegisterDumpProvider(&mdp);
 
   // Check that the dumper is not called if the memory category is not enabled.
@@ skipping 136 matching lines @@
   MockDumpProvider mdp1;
   MockDumpProvider mdp2;
 
   mdm_->RegisterDumpProvider(&mdp1);
   mdm_->RegisterDumpProvider(&mdp2);
   EnableTracing(kTraceCategory);
 
   EXPECT_CALL(mdp1, OnMemoryDump(_))
       .Times(MemoryDumpManager::kMaxConsecutiveFailuresCount)
       .WillRepeatedly(Return(false));
+
   EXPECT_CALL(mdp2, OnMemoryDump(_))
       .Times(1 + MemoryDumpManager::kMaxConsecutiveFailuresCount)
       .WillOnce(Return(false))
       .WillRepeatedly(Return(true));
   for (int i = 0; i < 1 + MemoryDumpManager::kMaxConsecutiveFailuresCount;
        i++) {
     mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED);
   }
 
   DisableTracing();
 }
 
+// Sneakily register an extra memory dump provider while an existing one is
+// dumping and expect it to take part in the already active tracing session.
+TEST_F(MemoryDumpManagerTest, RegisterDumperWhileDumping) {
+  MockDumpProvider mdp1;
+  MockDumpProvider mdp2;
+
+  mdp1.dump_provider_to_register_or_unregister = &mdp2;
+  mdm_->RegisterDumpProvider(&mdp1);
+  EnableTracing(kTraceCategory);
+
+  EXPECT_CALL(mdp1, OnMemoryDump(_))
+      .Times(4)
+      .WillOnce(Return(true))
+      .WillOnce(Invoke(
+          &mdp1, &MockDumpProvider::OnMemoryDump_RegisterExtraDumpProvider))
+      .WillRepeatedly(Return(true));
+
+  // Depending on the insertion order (before or after mdp1), mdp2 might be
+  // called also immediately after it gets registered.
+  EXPECT_CALL(mdp2, OnMemoryDump(_))
+      .Times(Between(2, 3))
+      .WillRepeatedly(Return(true));
+
+  for (int i = 0; i < 4; i++) {
+    mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED);
+  }
+
+  DisableTracing();
+}
+
+// Like the above, but suddenly unregister the dump provider.
+TEST_F(MemoryDumpManagerTest, UnregisterDumperWhileDumping) {
+  MockDumpProvider mdp1;
+  MockDumpProvider mdp2;
+
+  mdm_->RegisterDumpProvider(&mdp1, ThreadTaskRunnerHandle::Get());
+  mdm_->RegisterDumpProvider(&mdp2, ThreadTaskRunnerHandle::Get());
+  mdp1.dump_provider_to_register_or_unregister = &mdp2;
+  EnableTracing(kTraceCategory);
+
+  EXPECT_CALL(mdp1, OnMemoryDump(_))
+      .Times(4)
+      .WillOnce(Return(true))
+      .WillOnce(Invoke(&mdp1,
+                       &MockDumpProvider::OnMemoryDump_UnregisterDumpProvider))
+      .WillRepeatedly(Return(true));
+
+  // Depending on the insertion order (before or after mdp1), mdp2 might have
+  // been already called when OnMemoryDump_UnregisterDumpProvider happens.
+  EXPECT_CALL(mdp2, OnMemoryDump(_))
+      .Times(Between(1, 2))
+      .WillRepeatedly(Return(true));
+
+  for (int i = 0; i < 4; i++) {
+    mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED);
+  }
+
+  DisableTracing();
+}
+
 }  // namespace trace_event
 }  // namespace base