[tracing] Add test for memory-infra startup tracing

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/strings/stringprintf.h"
 #include "base/test/test_io_thread.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 "base/trace_event/trace_config_memory_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::AnyNumber;
 using testing::AtMost;
 using testing::Between;
 using testing::Invoke;
 using testing::Return;
 
 namespace base {
 namespace trace_event {
 namespace {
 MemoryDumpArgs g_high_detail_args = {MemoryDumpArgs::LevelOfDetail::HIGH};
 MemoryDumpArgs g_low_detail_args = {MemoryDumpArgs::LevelOfDetail::LOW};
-const char kTraceConfigWithTriggersFmt[] =
-    "{\"included_categories\":[\"%s\"],\"memory_dump_config\":{\"triggers\":["
-    "{\"mode\":\"light\", \"periodic_interval_ms\":1},"
-    "{\"mode\":\"detailed\", \"periodic_interval_ms\":5}]}}";
 }  // namespace
 
 // GTest matchers for MemoryDumpRequestArgs arguments.
 MATCHER(IsHighDetail, "") {
   return arg.level_of_detail == MemoryDumpArgs::LevelOfDetail::HIGH;
 }
 
 MATCHER(IsLowDetail, "") {
   return arg.level_of_detail == MemoryDumpArgs::LevelOfDetail::LOW;
 }
@@ skipping 63 matching lines @@
  protected:
   void InitializeMemoryDumpManager(bool is_coordinator) {
     mdm_->Initialize(delegate_.get(), is_coordinator);
   }
 
   void EnableTracingWithLegacyCategories(const char* category) {
     TraceLog::GetInstance()->SetEnabled(TraceConfig(category, ""),
                                         TraceLog::RECORDING_MODE);
   }
 
-  void EnableTracingWithTraceConfig(const char* trace_config) {
+  void EnableTracingWithTraceConfig(const std::string& trace_config) {
     TraceLog::GetInstance()->SetEnabled(TraceConfig(trace_config),
                                         TraceLog::RECORDING_MODE);
   }
 
   void DisableTracing() { TraceLog::GetInstance()->SetDisabled(); }
 
   bool IsPeriodicDumpingEnabled() const {
     return mdm_->periodic_dump_timer_.IsRunning();
   }
 
@@ skipping 449 matching lines @@
     MemoryDumpCallback callback =
         Bind(&MemoryDumpManagerTest::DumpCallbackAdapter, Unretained(this),
              MessageLoop::current()->task_runner(), run_loop.QuitClosure());
     mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
                             g_high_detail_args, callback);
     run_loop.Run();
   }
   EXPECT_FALSE(last_callback_success_);
 }
 
+// Checks that is the MemoryDumpManager is initialized after tracing already
+// began, it will still late-join the party (real use case: startup tracing).
+TEST_F(MemoryDumpManagerTest, InitializedAfterStartOfTracing) {
+  MockMemoryDumpProvider mdp;
+  mdm_->RegisterDumpProvider(&mdp);
+  EnableTracingWithLegacyCategories(MemoryDumpManager::kTraceCategory);
+
+  // First check that a RequestGlobalDump() issued before the MemoryDumpManager
+  // initialization gets NACK-ed cleanly.
+  {
+    EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(0);
+    EXPECT_CALL(*delegate_, RequestGlobalMemoryDump(_, _)).Times(0);
+    RunLoop run_loop;
+    MemoryDumpCallback callback =
+        Bind(&MemoryDumpManagerTest::DumpCallbackAdapter, Unretained(this),
+             MessageLoop::current()->task_runner(), run_loop.QuitClosure());
+    mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
+                            g_high_detail_args, callback);
+    run_loop.Run();
+    EXPECT_FALSE(last_callback_success_);
+  }
+
+  // Now late-initialize the MemoryDumpManager and check that the
+  // RequestGlobalDump completes successfully.
+  {
+    EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(1);
+    EXPECT_CALL(*delegate_, RequestGlobalMemoryDump(_, _)).Times(1);
+    InitializeMemoryDumpManager(false /* is_coordinator */);
+    RunLoop run_loop;
+    MemoryDumpCallback callback =
+        Bind(&MemoryDumpManagerTest::DumpCallbackAdapter, Unretained(this),
+             MessageLoop::current()->task_runner(), run_loop.QuitClosure());
+    mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
+                            g_high_detail_args, callback);
+    run_loop.Run();
+    EXPECT_TRUE(last_callback_success_);
+  }
+  DisableTracing();
+}
+
 // This test (and the MemoryDumpManagerTestCoordinator below) crystallizes the
 // expectations of the chrome://tracing UI and chrome telemetry w.r.t. periodic
 // dumps in memory-infra, handling gracefully the transition between the legacy
 // and the new-style (JSON-based) TraceConfig.
 TEST_F(MemoryDumpManagerTest, TraceConfigExpectations) {
   InitializeMemoryDumpManager(false /* is_coordinator */);
   MemoryDumpManagerDelegateForTesting& delegate = *delegate_;
 
   // Don't trigger the default behavior of the mock delegate in this test,
   // which would short-circuit the dump request to the actual
   // CreateProcessDump().
   // We don't want to create any dump in this test, only check whether the dumps
   // are requested or not.
   ON_CALL(delegate, RequestGlobalMemoryDump(_, _)).WillByDefault(Return());
 
   // Enabling memory-infra in a non-coordinator process should not trigger any
   // periodic dumps.
   EnableTracingWithLegacyCategories(MemoryDumpManager::kTraceCategory);
   EXPECT_FALSE(IsPeriodicDumpingEnabled());
   DisableTracing();
 
   // Enabling memory-infra with the new (JSON) TraceConfig in a non-coordinator
   // process with a fully defined trigger config should NOT enable any periodic
   // dumps.
-  const std::string kTraceConfigWithTriggers = StringPrintf(
-      kTraceConfigWithTriggersFmt, MemoryDumpManager::kTraceCategory);
-  EnableTracingWithTraceConfig(kTraceConfigWithTriggers.c_str());
+  EnableTracingWithTraceConfig(
+      TraceConfigMemoryTestUtil::GetTraceConfig_PeriodicTriggers(1, 5));
   EXPECT_FALSE(IsPeriodicDumpingEnabled());
   DisableTracing();
 }
 
 TEST_F(MemoryDumpManagerTest, TraceConfigExpectationsWhenIsCoordinator) {
   InitializeMemoryDumpManager(true /* is_coordinator */);
   MemoryDumpManagerDelegateForTesting& delegate = *delegate_;
   ON_CALL(delegate, RequestGlobalMemoryDump(_, _)).WillByDefault(Return());
 
   // Enabling memory-infra with the legacy TraceConfig (category filter) in
   // a coordinator process should enable periodic dumps.
   EnableTracingWithLegacyCategories(MemoryDumpManager::kTraceCategory);
   EXPECT_TRUE(IsPeriodicDumpingEnabled());
   DisableTracing();
 
   // Enabling memory-infra with the new (JSON) TraceConfig in a coordinator
   // process without specifying any "memory_dump_config" section should enable
   // periodic dumps. This is to preserve the behavior chrome://tracing UI, that
   // is: ticking memory-infra should dump periodically with the default config.
-  const std::string kTraceConfigWithNoMemorDumpConfig = StringPrintf(
-      "{\"included_categories\":[\"%s\"]}", MemoryDumpManager::kTraceCategory);
-  EnableTracingWithTraceConfig(kTraceConfigWithNoMemorDumpConfig.c_str());
+  EnableTracingWithTraceConfig(
+      TraceConfigMemoryTestUtil::GetTraceConfig_NoTriggers());
   EXPECT_TRUE(IsPeriodicDumpingEnabled());
   DisableTracing();
 
   // Enabling memory-infra with the new (JSON) TraceConfig in a coordinator
   // process with an empty "memory_dump_config" should NOT enable periodic
   // dumps. This is the way telemetry is supposed to use memory-infra with
   // only explicitly triggered dumps.
-  const std::string kTraceConfigWithNoTriggers = StringPrintf(
-      "{\"included_categories\":[\"%s\"], \"memory_dump_config\":{}",
-      MemoryDumpManager::kTraceCategory);
-  EnableTracingWithTraceConfig(kTraceConfigWithNoTriggers.c_str());
+  EnableTracingWithTraceConfig(
+      TraceConfigMemoryTestUtil::GetTraceConfig_EmptyTriggers());
   EXPECT_FALSE(IsPeriodicDumpingEnabled());
   DisableTracing();
 
   // Enabling memory-infra with the new (JSON) TraceConfig in a coordinator
   // process with a fully defined trigger config should cause periodic dumps to
   // be performed in the correct order.
   RunLoop run_loop;
   auto quit_closure = run_loop.QuitClosure();
 
-  // The expected sequence with config of light=1ms, heavy=5ms is H,L,L,L,H,...
+  const int kHeavyDumpRate = 5;
+  const int kLightDumpPeriodMs = 1;
+  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(IsHighDetailArgs(), _));
-  EXPECT_CALL(delegate, RequestGlobalMemoryDump(IsLowDetailArgs(), _)).Times(3);
+  EXPECT_CALL(delegate, RequestGlobalMemoryDump(IsLowDetailArgs(), _))
+      .Times(kHeavyDumpRate - 1);
   EXPECT_CALL(delegate, RequestGlobalMemoryDump(IsHighDetailArgs(), _));
-  EXPECT_CALL(delegate, RequestGlobalMemoryDump(IsLowDetailArgs(), _)).Times(2);
+  EXPECT_CALL(delegate, RequestGlobalMemoryDump(IsLowDetailArgs(), _))
+      .Times(kHeavyDumpRate - 2);
   EXPECT_CALL(delegate, RequestGlobalMemoryDump(IsLowDetailArgs(), _))
       .WillOnce(Invoke([quit_closure](const MemoryDumpRequestArgs& args,
                                       const MemoryDumpCallback& callback) {
         ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, quit_closure);
       }));
 
   // Swallow all the final spurious calls until tracing gets disabled.
   EXPECT_CALL(delegate, RequestGlobalMemoryDump(_, _)).Times(AnyNumber());
 
-  const std::string kTraceConfigWithTriggers = StringPrintf(
-      kTraceConfigWithTriggersFmt, MemoryDumpManager::kTraceCategory);
-  EnableTracingWithTraceConfig(kTraceConfigWithTriggers.c_str());
+  EnableTracingWithTraceConfig(
+      TraceConfigMemoryTestUtil::GetTraceConfig_PeriodicTriggers(
+          kLightDumpPeriodMs, kHeavyDumpPeriodMs));
   run_loop.Run();
   DisableTracing();
 }
 
 }  // namespace trace_event
 }  // namespace base