[tracing] MemoryDumpManager uses TraceConfig to set the periodic dump timers

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/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 "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::AtMost;
 using testing::Between;
 using testing::Invoke;
 using testing::Return;
 
 namespace base {
 namespace trace_event {
 namespace {
-MemoryDumpArgs high_detail_args = {MemoryDumpArgs::LevelOfDetail::HIGH};
-MemoryDumpArgs low_detail_args = {MemoryDumpArgs::LevelOfDetail::LOW};
+MemoryDumpArgs g_high_detail_args = {MemoryDumpArgs::LevelOfDetail::HIGH};
+MemoryDumpArgs g_low_detail_args = {MemoryDumpArgs::LevelOfDetail::LOW};
 }
 
 // Testing MemoryDumpManagerDelegate which short-circuits dump requests locally
 // instead of performing IPC dances.
 class MemoryDumpManagerDelegateForTesting : public MemoryDumpManagerDelegate {
  public:
   void RequestGlobalMemoryDump(const MemoryDumpRequestArgs& args,
                                const MemoryDumpCallback& callback) override {
     CreateProcessDump(args, callback);
   }
 
   bool IsCoordinatorProcess() const override { return false; }
   uint64 GetTracingProcessId() const override {
     return MemoryDumpManager::kInvalidTracingProcessId;
   }
 };
 
+class MemoryDumpManagerDelegateForPeriodicDumpTest
+    : public MemoryDumpManagerDelegateForTesting {

[Primiano Tucci (use gerrit), 2015/09/03 22:44:51]

Ah also why doesn't this inherit just from MemoryDumpManagerDelegate ?

[ssid, 2015/09/04 10:43:47]

Because the delegate objects are owned by MemoryDumpManagerTest. It cannot have
a scoped ptr of MemoryDumpManagerDelegate, since it is virtual. So, it holds
objects of MemoryDumpManagerDelegateForTesting instead.
Also, there is one extra ,method that needs to be copied.

+ public:
+  MemoryDumpManagerDelegateForPeriodicDumpTest(int dump_calls_to_quit,
+                                               int expected_high_dump_ratio,
+                                               base::Closure quit_closure)
+      : dump_call_count_(0),
+        dump_calls_to_quit_(dump_calls_to_quit),
+        expected_high_dump_ratio_(expected_high_dump_ratio),
+        quit_closure_(quit_closure) {}
+
+  ~MemoryDumpManagerDelegateForPeriodicDumpTest() override {}
+
+  MOCK_METHOD2(RequestGlobalMemoryDump,
+               void(const MemoryDumpRequestArgs& args,
+                    const MemoryDumpCallback& callback));
+
+  // RequestGlobalMemoryDump override for SchedulePeriodicDumpsFromTraceConfig
+  // test.
+  void RequestGlobalMemoryDump_QuitAfterCalls(
+      const MemoryDumpRequestArgs& args,
+      const MemoryDumpCallback& callback) {
+    CreateProcessDump(args, callback);

[Primiano Tucci (use gerrit), 2015/09/03 22:44:13]

No need to create any process dump

[ssid, 2015/09/04 10:43:47]

Done.

+    if (dump_call_count_ % expected_high_dump_ratio_ == 0) {

[Primiano Tucci (use gerrit), 2015/09/03 22:44:13]

I don't think you need all this logic here. You can handle the sequencing with
the EXPECT_CALL + predicate matching in the TEST_F.
In other words I think you need a super simple mock delegate (with just the MOCK
method) and then, in the TEST_F

EXPECT_CALL(*delegate.get(), RequestGlobalMemoryDump(g_high_detail_args,
_)).times(1)
EXPECT_CALL(*delegate.get(), RequestGlobalMemoryDump(g_low_detail_args,
_)).times(2)
EXPECT_CALL(*delegate.get(), RequestGlobalMemoryDump(g_high_detail_args,
_)).times(1)
EXPECT_CALL(*delegate.get(), RequestGlobalMemoryDump(g_low_detail_args,
_)).times(2)
EXPECT_CALL(*delegate.get(), RequestGlobalMemoryDump(g_high_detail_args,
_)).WillOnce(Invoke(... lambda for posting the closure)

[ssid, 2015/09/04 10:43:47]

No, I cannot do that. I can define only one expect_call for a function. That i
taken as the total number of calls the function gets in the exec of the test. If
I define multiple times, the test will surely fail at multiple places saying the
function is called 5 times but it is said as 2 / 1 here.
So I have to define something like called with high args 2 times and called with
low args 3 times.
But for this I need to have an "==" defined in MemoryDumpRequestArgs. This
struct holds MemoryDumpArgs, which means I need an == defined in here as well.
Instead of defining multiple "==" in production code, I made the test logic
complicated. Also, this tests for the correct order of dump calls, not just the
number of high and low calls.

+      EXPECT_EQ(MemoryDumpArgs::LevelOfDetail::HIGH,
+                args.dump_args.level_of_detail);
+    } else {
+      EXPECT_EQ(MemoryDumpArgs::LevelOfDetail::LOW,
+                args.dump_args.level_of_detail);
+    }
+    if (++dump_call_count_ == dump_calls_to_quit_) {
+      TraceLog::GetInstance()->SetDisabled();
+      ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, quit_closure_);
+    }
+  }
+
+  bool IsCoordinatorProcess() const override { return true; }
+
+ private:
+  int dump_call_count_;
+  int dump_calls_to_quit_;
+  int expected_high_dump_ratio_;
+  base::Closure quit_closure_;
+};
+
 class MemoryDumpManagerTest : public testing::Test {
  public:
   void SetUp() override {
     last_callback_success_ = false;
     message_loop_.reset(new MessageLoop());
     mdm_.reset(new MemoryDumpManager());
     MemoryDumpManager::SetInstanceForTesting(mdm_.get());
     ASSERT_EQ(mdm_, MemoryDumpManager::GetInstance());
     MemoryDumpManager::GetInstance()->Initialize();
-    MemoryDumpManager::GetInstance()->SetDelegate(&delegate_);
   }
 
   void TearDown() override {
     MemoryDumpManager::SetInstanceForTesting(nullptr);
     mdm_.reset();
     message_loop_.reset();
     TraceLog::DeleteForTesting();
   }
 
   void DumpCallbackAdapter(scoped_refptr<SingleThreadTaskRunner> task_runner,
                            Closure closure,
                            uint64 dump_guid,
                            bool success) {
     last_callback_success_ = success;
     task_runner->PostTask(FROM_HERE, closure);
   }
 
  protected:
+  // This enalbes tracing using the legacy category filter string.
   void EnableTracing(const char* category) {
+    delegate_.reset(new MemoryDumpManagerDelegateForTesting());
+    MemoryDumpManager::GetInstance()->SetDelegate(delegate_.get());
     TraceLog::GetInstance()->SetEnabled(
         TraceConfig(category, ""), TraceLog::RECORDING_MODE);
   }
 
+  void SetDelegate(scoped_ptr<MemoryDumpManagerDelegateForTesting> delegate) {
+    delegate_ = delegate.Pass();
+    MemoryDumpManager::GetInstance()->SetDelegate(delegate_.get());
+  }
+
+  void EnableTracingWithTraceConfig(const char* trace_config) {
+    DCHECK(delegate_);
+    TraceConfig tc(trace_config);
+    TraceLog::GetInstance()->SetEnabled(tc, TraceLog::RECORDING_MODE);
+  }
+
   void DisableTracing() { TraceLog::GetInstance()->SetDisabled(); }
 
   scoped_ptr<MemoryDumpManager> mdm_;
   bool last_callback_success_;
+  scoped_ptr<MemoryDumpManagerDelegateForTesting> delegate_;
 
  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()
       : dump_provider_to_register_or_unregister(nullptr),
         last_session_state_(nullptr),
@@ skipping 65 matching lines @@
 };
 
 TEST_F(MemoryDumpManagerTest, SingleDumper) {
   MockDumpProvider mdp;
   mdm_->RegisterDumpProvider(&mdp);
 
   // Check that the dumper is not called if the memory category is not enabled.
   EnableTracing("foo-and-bar-but-not-memory");
   EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(0);
   mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                          high_detail_args);
+                          g_high_detail_args);
   DisableTracing();
 
   // Now repeat enabling the memory category and check that the dumper is
   // invoked this time.
   EnableTracing(MemoryDumpManager::kTraceCategory);
   EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(3).WillRepeatedly(Return(true));
   for (int i = 0; i < 3; ++i)
     mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                            high_detail_args);
+                            g_high_detail_args);
   DisableTracing();
 
   mdm_->UnregisterDumpProvider(&mdp);
 
   // Finally check the unregister logic (no calls to the mdp after unregister).
   EnableTracing(MemoryDumpManager::kTraceCategory);
   EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(0);
   mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                          high_detail_args);
+                          g_high_detail_args);
   TraceLog::GetInstance()->SetDisabled();
 }
 
 TEST_F(MemoryDumpManagerTest, CheckMemoryDumpArgs) {
   // Check that requesting dumps with high level of detail actually propagates
   // to OnMemoryDump() call on dump providers.
   MockDumpProvider mdp_high_detail(MemoryDumpArgs::LevelOfDetail::HIGH);
   mdm_->RegisterDumpProvider(&mdp_high_detail);
 
   EnableTracing(MemoryDumpManager::kTraceCategory);
   EXPECT_CALL(mdp_high_detail, OnMemoryDump(_, _))
       .Times(1)
       .WillRepeatedly(
           Invoke(&mdp_high_detail,
                  &MockDumpProvider::OnMemoryDump_CheckMemoryDumpArgs));
   mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                          high_detail_args);
+                          g_high_detail_args);
   DisableTracing();
   mdm_->UnregisterDumpProvider(&mdp_high_detail);
 
   // Check that requesting dumps with low level of detail actually propagates to
   // OnMemoryDump() call on dump providers.
   MockDumpProvider mdp_low_detail(MemoryDumpArgs::LevelOfDetail::LOW);
   mdm_->RegisterDumpProvider(&mdp_low_detail);
 
   EnableTracing(MemoryDumpManager::kTraceCategory);
   EXPECT_CALL(mdp_low_detail, OnMemoryDump(_, _))
       .Times(1)
       .WillRepeatedly(
           Invoke(&mdp_low_detail,
                  &MockDumpProvider::OnMemoryDump_CheckMemoryDumpArgs));
   mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                          low_detail_args);
+                          g_low_detail_args);
   DisableTracing();
   mdm_->UnregisterDumpProvider(&mdp_low_detail);
 }
 
 TEST_F(MemoryDumpManagerTest, SharedSessionState) {
   MockDumpProvider mdp1;
   MockDumpProvider mdp2;
   mdm_->RegisterDumpProvider(&mdp1);
   mdm_->RegisterDumpProvider(&mdp2);
 
   EnableTracing(MemoryDumpManager::kTraceCategory);
   EXPECT_CALL(mdp1, OnMemoryDump(_, _))
       .Times(2)
       .WillRepeatedly(
           Invoke(&mdp1, &MockDumpProvider::OnMemoryDump_CheckSessionState));
   EXPECT_CALL(mdp2, OnMemoryDump(_, _))
       .Times(2)
       .WillRepeatedly(
           Invoke(&mdp2, &MockDumpProvider::OnMemoryDump_CheckSessionState));
 
   for (int i = 0; i < 2; ++i)
     mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                            high_detail_args);
+                            g_high_detail_args);
 
   DisableTracing();
 }
 
 TEST_F(MemoryDumpManagerTest, MultipleDumpers) {
   MockDumpProvider mdp1;
   MockDumpProvider mdp2;
 
   // Enable only mdp1.
   mdm_->RegisterDumpProvider(&mdp1);
   EnableTracing(MemoryDumpManager::kTraceCategory);
   EXPECT_CALL(mdp1, OnMemoryDump(_, _)).Times(1).WillRepeatedly(Return(true));
   EXPECT_CALL(mdp2, OnMemoryDump(_, _)).Times(0);
   mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                          high_detail_args);
+                          g_high_detail_args);
   DisableTracing();
 
   // Invert: enable mdp1 and disable mdp2.
   mdm_->UnregisterDumpProvider(&mdp1);
   mdm_->RegisterDumpProvider(&mdp2);
   EnableTracing(MemoryDumpManager::kTraceCategory);
   EXPECT_CALL(mdp1, OnMemoryDump(_, _)).Times(0);
   EXPECT_CALL(mdp2, OnMemoryDump(_, _)).Times(1).WillRepeatedly(Return(true));
   mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                          high_detail_args);
+                          g_high_detail_args);
   DisableTracing();
 
   // Enable both mdp1 and mdp2.
   mdm_->RegisterDumpProvider(&mdp1);
   EnableTracing(MemoryDumpManager::kTraceCategory);
   EXPECT_CALL(mdp1, OnMemoryDump(_, _)).Times(1).WillRepeatedly(Return(true));
   EXPECT_CALL(mdp2, OnMemoryDump(_, _)).Times(1).WillRepeatedly(Return(true));
   mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                          high_detail_args);
+                          g_high_detail_args);
   DisableTracing();
 }
 
 // Verify that whether OnMemoryDump is called depends only on the current
 // registration state and not on previous registrations and dumps.
 TEST_F(MemoryDumpManagerTest, RegistrationConsistency) {
   MockDumpProvider mdp;
 
   mdm_->RegisterDumpProvider(&mdp);
 
   {
     EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(1);
     EnableTracing(MemoryDumpManager::kTraceCategory);
     mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                            high_detail_args);
+                            g_high_detail_args);
     DisableTracing();
   }
 
   mdm_->UnregisterDumpProvider(&mdp);
 
   {
     EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(0);
     EnableTracing(MemoryDumpManager::kTraceCategory);
     mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                            high_detail_args);
+                            g_high_detail_args);
     DisableTracing();
   }
 
   mdm_->RegisterDumpProvider(&mdp);
   mdm_->UnregisterDumpProvider(&mdp);
 
   {
     EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(0);
     EnableTracing(MemoryDumpManager::kTraceCategory);
     mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                            high_detail_args);
+                            g_high_detail_args);
     DisableTracing();
   }
 
   mdm_->RegisterDumpProvider(&mdp);
   mdm_->UnregisterDumpProvider(&mdp);
   mdm_->RegisterDumpProvider(&mdp);
 
   {
     EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(1);
     EnableTracing(MemoryDumpManager::kTraceCategory);
     mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                            high_detail_args);
+                            g_high_detail_args);
     DisableTracing();
   }
 }
 
 // Checks that the MemoryDumpManager respects the thread affinity when a
 // MemoryDumpProvider specifies a task_runner(). The test starts creating 8
 // threads and registering a MemoryDumpProvider on each of them. At each
 // iteration, one thread is removed, to check the live unregistration logic.
 TEST_F(MemoryDumpManagerTest, RespectTaskRunnerAffinity) {
   const uint32 kNumInitialThreads = 8;
@@ skipping 19 matching lines @@
   EnableTracing(MemoryDumpManager::kTraceCategory);
 
   while (!threads.empty()) {
     last_callback_success_ = false;
     {
       RunLoop run_loop;
       MemoryDumpCallback callback =
           Bind(&MemoryDumpManagerTest::DumpCallbackAdapter, Unretained(this),
                MessageLoop::current()->task_runner(), run_loop.QuitClosure());
       mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                              high_detail_args, callback);
+                              g_high_detail_args, callback);
       // This nested message loop (|run_loop|) will be quit if and only if
       // the RequestGlobalDump callback is invoked.
       run_loop.Run();
     }
     EXPECT_TRUE(last_callback_success_);
 
     // Unregister a MDP and destroy one thread at each iteration to check the
     // live unregistration logic. The unregistration needs to happen on the same
     // thread the MDP belongs to.
     {
@@ skipping 27 matching lines @@
       .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,
-                            high_detail_args);
+                            g_high_detail_args);
   }
 
   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;
@@ skipping 10 matching lines @@
       .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,
-                            high_detail_args);
+                            g_high_detail_args);
   }
 
   DisableTracing();
 }
 
 // Like the above, but suddenly unregister the dump provider.
 TEST_F(MemoryDumpManagerTest, UnregisterDumperWhileDumping) {
   MockDumpProvider mdp1;
   MockDumpProvider mdp2;
 
@@ skipping 10 matching lines @@
       .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,
-                            high_detail_args);
+                            g_high_detail_args);
   }
 
   DisableTracing();
 }
 
 // Verify that the dump does not abort when unregistering a provider while
 // dumping from a different thread than the dumping thread.
 TEST_F(MemoryDumpManagerTest, UnregisterDumperFromThreadWhileDumping) {
   ScopedVector<TestIOThread> threads;
   ScopedVector<MockDumpProvider> mdps;
@@ skipping 29 matching lines @@
         .WillOnce(Invoke(on_dump));
   }
 
   last_callback_success_ = false;
   MemoryDumpCallback callback =
       Bind(&MemoryDumpManagerTest::DumpCallbackAdapter, Unretained(this),
            MessageLoop::current()->task_runner(), run_loop.QuitClosure());
 
   EnableTracing(MemoryDumpManager::kTraceCategory);
   MemoryDumpRequestArgs request_args = {0, MemoryDumpType::EXPLICITLY_TRIGGERED,
-                                        high_detail_args};
+                                        g_high_detail_args};
   mdm_->CreateProcessDump(request_args, callback);
 
   run_loop.Run();
 
   ASSERT_EQ(1, on_memory_dump_call_count);
   ASSERT_EQ(true, last_callback_success_);
 
   DisableTracing();
 }
 
 // Ensures that a NACK callback is invoked if RequestGlobalDump is called when
 // tracing is not enabled.
 TEST_F(MemoryDumpManagerTest, CallbackCalledOnFailure) {
   MockDumpProvider mdp1;
 
   mdm_->RegisterDumpProvider(&mdp1);
   EXPECT_CALL(mdp1, OnMemoryDump(_, _)).Times(0);
 
   last_callback_success_ = true;
   {
     RunLoop run_loop;
     MemoryDumpCallback callback =
         Bind(&MemoryDumpManagerTest::DumpCallbackAdapter, Unretained(this),
              MessageLoop::current()->task_runner(), run_loop.QuitClosure());
     mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED,
-                            high_detail_args, callback);
+                            g_high_detail_args, callback);
     run_loop.Run();
   }
   EXPECT_FALSE(last_callback_success_);
 }
 
+TEST_F(MemoryDumpManagerTest, SchedulePeriodicDumpsFromTraceConfig) {
+  const char kMemoryDumpTraceConfigString[] =
+    "{"
+      "\"included_categories\":["
+        "\"disabled-by-default-memory-infra\""
+      "],"
+      "\"memory_dump_config\":{"
+        "\"triggers\":["
+          "{"
+            "\"mode\":\"light\","
+            "\"periodic_interval_ms\":1"
+          "},"
+          "{"
+            "\"mode\":\"detailed\","
+            "\"periodic_interval_ms\":3"
+          "}"
+        "]"
+      "}"
+    "}";
+
+  RunLoop run_loop;
+  scoped_ptr<MemoryDumpManagerDelegateForPeriodicDumpTest> delegate(
+      new MemoryDumpManagerDelegateForPeriodicDumpTest(
+          5 /* dump_calls_to_quit */, 3 /* expected_high_dump_ratio */,
+          run_loop.QuitClosure()));
+  EXPECT_CALL(*delegate.get(), RequestGlobalMemoryDump(_, _))
+      .Times(5)
+      .WillRepeatedly(
+          Invoke(delegate.get(), &MemoryDumpManagerDelegateForPeriodicDumpTest::
+                                     RequestGlobalMemoryDump_QuitAfterCalls));
+  SetDelegate(delegate.Pass());
+  EnableTracingWithTraceConfig(kMemoryDumpTraceConfigString);
+
+  run_loop.Run();
+}
+
 }  // namespace trace_event
 }  // namespace base