memory-infra: Add SUMMARY_ONLY MemoryDumpType

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 1091 matching lines @@
 
   ASSERT_EQ(3u, events.size());
   ASSERT_EQ(1u, trace_analyzer::CountMatches(events, Query::EventPidIs(123)));
   ASSERT_EQ(1u, trace_analyzer::CountMatches(events, Query::EventPidIs(456)));
   ASSERT_EQ(1u, trace_analyzer::CountMatches(
                     events, Query::EventPidIs(GetCurrentProcId())));
   ASSERT_EQ(events[0]->id, events[1]->id);
   ASSERT_EQ(events[0]->id, events[2]->id);
 }
 
+TEST_F(MemoryDumpManagerTest, SummaryOnlyDumpsArentAddedToTrace) {
+  using trace_analyzer::Query;
+
+  InitializeMemoryDumpManager(false /* is_coordinator */);
+
+  // Standard provider with default options (create dump for current process).
+  MemoryDumpProvider::Options options;
+  MockMemoryDumpProvider mdp;
+  RegisterDumpProvider(&mdp, nullptr, options);
+
+  EnableTracingWithLegacyCategories(MemoryDumpManager::kTraceCategory);
+  EXPECT_CALL(*delegate_, RequestGlobalMemoryDump(_, _)).Times(2);
+  EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(2).WillRepeatedly(Return(true));
+  RequestGlobalDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
+                           MemoryDumpLevelOfDetail::DETAILED);

[Primiano Tucci (use gerrit), 2017/04/25 18:02:22]

i'd s/DETAILED/BACKGROUND/ just in case in future we add some check that
SUMMARY_ONLY must be background and remove the frustration in that case of
having a red CQ and having to update this test :)
Shouldn't really change the semantics of this test.

[hjd, 2017/04/26 11:11:58]

Done.

+  RequestGlobalDumpAndWait(MemoryDumpType::SUMMARY_ONLY,
+                           MemoryDumpLevelOfDetail::DETAILED);
+  DisableTracing();
+
+  // Flush the trace into JSON.
+  trace_event::TraceResultBuffer buffer;

[Primiano Tucci (use gerrit), 2017/04/25 18:02:22]

maybe you can factor this and the one in DumpOnBehalfOfOtherProcess into a
function in the anonymous namespace, something like

std::unique_ptr<trace_analyzer::TraceAnalyzer> GetDeserializedTrace();

[hjd, 2017/04/26 11:11:58]

Done.

+  TraceResultBuffer::SimpleOutput trace_output;
+  buffer.SetOutputCallback(trace_output.GetCallback());
+  RunLoop run_loop;
+  buffer.Start();
+  trace_event::TraceLog::GetInstance()->Flush(
+      Bind(&OnTraceDataCollected, run_loop.QuitClosure(), Unretained(&buffer)));
+  run_loop.Run();
+  buffer.Finish();
+
+  // Analyze the JSON.
+  std::unique_ptr<trace_analyzer::TraceAnalyzer> analyzer = WrapUnique(
+      trace_analyzer::TraceAnalyzer::Create(trace_output.json_output));
+  trace_analyzer::TraceEventVector events;
+  analyzer->FindEvents(Query::EventPhaseIs(TRACE_EVENT_PHASE_MEMORY_DUMP),
+                       &events);
+
+  ASSERT_EQ(1u, events.size());
+  ASSERT_EQ(1u, trace_analyzer::CountMatches(

[Primiano Tucci (use gerrit), 2017/04/25 18:02:22]

I'd replace this with 
ASSERT_TRUE(trace_analyzer::CountMatches(trace_analyzer::EventNameIs(MemoryDumpTypeToString(MemoryDumpType::EXPLICITLY_TRIGGERED))

[hjd, 2017/04/26 11:11:58]

Done.

+                    events, Query::EventPidIs(GetCurrentProcId())));
+}
+
 // Tests the basics of the UnregisterAndDeleteDumpProviderSoon(): the
 // unregistration should actually delete the providers and not leak them.
 TEST_F(MemoryDumpManagerTest, UnregisterAndDeleteDumpProviderSoon) {
   InitializeMemoryDumpManager(false /* is_coordinator */);
   static const int kNumProviders = 3;
   int dtor_count = 0;
   std::vector<std::unique_ptr<MemoryDumpProvider>> mdps;
   for (int i = 0; i < kNumProviders; ++i) {
     std::unique_ptr<MockMemoryDumpProvider> mdp(new MockMemoryDumpProvider);
     mdp->enable_mock_destructor = true;
@@ skipping 154 matching lines @@
   // successful we also managed to add the dump to the trace.
   EXPECT_FALSE(last_callback_success_);
 
   mdm_->Disable();
 
   mdm_->UnregisterDumpProvider(&mdp);
 }
 
 }  // namespace trace_event
 }  // namespace base