[tracing] Simplify design of MemoryAllocatorDump

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"
@@ skipping 62 matching lines @@
   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() {}
-  MockDumpProvider(const scoped_refptr<SingleThreadTaskRunner>& task_runner)
+
+  explicit MockDumpProvider(
+      const scoped_refptr<SingleThreadTaskRunner>& task_runner)
       : MemoryDumpProvider(task_runner) {}
+
+  // Ctor for the SharedSessionState test.
+  explicit MockDumpProvider(const std::string& id) {
+    DeclareAllocatorAttribute("allocator" + id, "attr" + id, "type" + id);
+  }
+
   MOCK_METHOD1(DumpInto, bool(ProcessMemoryDump* pmd));
 
   // DumpInto() override for the ActiveDumpProviderConsistency test.
   bool DumpIntoAndCheckDumpProviderCurrentlyActive(ProcessMemoryDump* pmd) {
     EXPECT_EQ(
         this,
         MemoryDumpManager::GetInstance()->dump_provider_currently_active());
     return true;
   }
 
   // DumpInto() override for the RespectTaskRunnerAffinity test.
   bool DumpIntoAndCheckTaskRunner(ProcessMemoryDump* pmd) {
     EXPECT_TRUE(task_runner()->RunsTasksOnCurrentThread());
     return true;
   }
 
+  // DumpInto() override for the SharedSessionState test.
+  bool DumpIntoAndCheckSessionState(ProcessMemoryDump* pmd) {
+    EXPECT_TRUE(pmd->session_state());
+    const auto& attrs_type_info =
+        pmd->session_state()->allocators_attributes_type_info;
+    EXPECT_TRUE(attrs_type_info.Exists("allocator1", "attr1"));
+    EXPECT_TRUE(attrs_type_info.Exists("allocator2", "attr2"));
+    return true;
+  }
+
   const char* GetFriendlyName() const override { return "MockDumpProvider"; }
 };
 
 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, DumpInto(_)).Times(0);
@@ skipping 10 matching lines @@
 
   mdm_->UnregisterDumpProvider(&mdp);
 
   // Finally check the unregister logic (no calls to the mdp after unregister).
   EnableTracing(kTraceCategory);
   EXPECT_CALL(mdp, DumpInto(_)).Times(0);
   mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED);
   TraceLog::GetInstance()->SetDisabled();
 }
 
+TEST_F(MemoryDumpManagerTest, SharedSessionState) {
+  MockDumpProvider mdp1("1");  // Will declare an allocator property "attr1".
+  MockDumpProvider mdp2("2");  // Will declare an allocator property "attr2".
+  mdm_->RegisterDumpProvider(&mdp1);
+  mdm_->RegisterDumpProvider(&mdp2);
+
+  EnableTracing(kTraceCategory);
+  EXPECT_CALL(mdp1, DumpInto(_)).Times(2).WillRepeatedly(
+      Invoke(&mdp1, &MockDumpProvider::DumpIntoAndCheckSessionState));
+  EXPECT_CALL(mdp2, DumpInto(_)).Times(2).WillRepeatedly(
+      Invoke(&mdp2, &MockDumpProvider::DumpIntoAndCheckSessionState));
+
+  for (int i = 0; i < 2; ++i)
+    mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED);
+
+  DisableTracing();
+}
+
 TEST_F(MemoryDumpManagerTest, MultipleDumpers) {
   MockDumpProvider mdp1;
   MockDumpProvider mdp2;
 
   // Enable only mdp1.
   mdm_->RegisterDumpProvider(&mdp1);
   EnableTracing(kTraceCategory);
   EXPECT_CALL(mdp1, DumpInto(_)).Times(1).WillRepeatedly(Return(true));
   EXPECT_CALL(mdp2, DumpInto(_)).Times(0);
   mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED);
@@ skipping 118 matching lines @@
       .WillRepeatedly(Invoke(
           &mdp2,
           &MockDumpProvider::DumpIntoAndCheckDumpProviderCurrentlyActive));
   mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED);
   mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED);
   DisableTracing();
 }
 
 }  // namespace trace_event
 }  // namespace base