[tracing] Introduce "allowed_dump_modes" for memory dump config

base/trace_event/memory_dump_manager.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 <algorithm>
 #include <utility>
 
 #include "base/atomic_sequence_num.h"
@@ skipping 113 matching lines @@
 
 // static
 void MemoryDumpManager::SetInstanceForTesting(MemoryDumpManager* instance) {
   g_instance_for_testing = instance;
 }
 
 MemoryDumpManager::MemoryDumpManager()
     : delegate_(nullptr),
       is_coordinator_(false),
       memory_tracing_enabled_(0),
+      periodic_dump_timer_(this),
       tracing_process_id_(kInvalidTracingProcessId),
       dumper_registrations_ignored_for_testing_(false),
       heap_profiling_enabled_(false) {
   g_next_guid.GetNext();  // Make sure that first guid is not zero.
 
   // At this point the command line may not be initialized but we try to
   // enable the heap profiler to capture allocations as soon as possible.
   EnableHeapProfilingIfNeeded();
 }
 
@@ skipping 184 matching lines @@
   // to just skip it, without actually invoking the |mdp|, which might be
   // destroyed by the caller soon after this method returns.
   (*mdp_iter)->disabled = true;
   dump_providers_.erase(mdp_iter);
 }
 
 void MemoryDumpManager::RequestGlobalDump(
     MemoryDumpType dump_type,
     MemoryDumpLevelOfDetail level_of_detail,
     const MemoryDumpCallback& callback) {
-  // Bail out immediately if tracing is not enabled at all.
-  if (!UNLIKELY(subtle::NoBarrier_Load(&memory_tracing_enabled_))) {
+  // Bail out immediately if tracing is not enabled at all or if the dump mode
+  // is not allowed.
+  if (!UNLIKELY(subtle::NoBarrier_Load(&memory_tracing_enabled_)) ||
+      !IsDumpModeAllowed(level_of_detail)) {
     VLOG(1) << "Global memory dump failed because " << kTraceCategory
-            << " tracing category is not enabled";
+            << " tracing category is not enabled or the requested dump mode is "
+               "not allowed by trace config.";
     if (!callback.is_null())
       callback.Run(0u /* guid */, false /* success */);
     return;
   }
 
   const uint64_t guid =
       TraceLog::GetInstance()->MangleEventId(g_next_guid.GetNext());
 
   // Creates an async event to keep track of the global dump evolution.
   // The |wrapped_callback| will generate the ASYNC_END event and then invoke
@@ skipping 348 matching lines @@
     session_state_ = nullptr;
   }
 
   // Thread stops are blocking and must be performed outside of the |lock_|
   // or will deadlock (e.g., if SetupNextMemoryDump() tries to acquire it).
   periodic_dump_timer_.Stop();
   if (dump_thread)
     dump_thread->Stop();
 }
 
+bool MemoryDumpManager::IsDumpModeAllowed(
+    MemoryDumpLevelOfDetail dump_mode) const {
+  return session_state_->memory_dump_config().allowed_dump_modes.count(

[Primiano Tucci (use gerrit), 2016/06/09 18:46:39]

- Take the AutoLock lock(lock_); session_state is always accessed under the
lock.
Don't worry about RequestGlobalMemoryDump locking twice, It's ok, once you hit
this you are out of the fast-path (we established we are going to spend time
doing a dump, in which case a lock is not influent)
- You need a if(!session_state) return false, otherwise this will crash if you
call this outside of a tracing session

[ssid, 2016/06/09 21:34:15]

Fixed the lock. Also renamed the session_state getter function which reads
without lock.
Did not add the check because none calls this when tracing is not enabled and
wanted it to fail. The request calls checks for tracing enabled first before
calling.

+             dump_mode) != 0;
+}
+
 uint64_t MemoryDumpManager::GetTracingProcessId() const {
   return delegate_->GetTracingProcessId();
 }
 
 MemoryDumpManager::MemoryDumpProviderInfo::MemoryDumpProviderInfo(
     MemoryDumpProvider* dump_provider,
     const char* name,
     scoped_refptr<SequencedTaskRunner> task_runner,
     const MemoryDumpProvider::Options& options,
     bool whitelisted_for_background_mode)
@@ skipping 43 matching lines @@
                                              const MemoryDumpArgs& dump_args) {
   auto iter = process_dumps.find(pid);
   if (iter == process_dumps.end()) {
     std::unique_ptr<ProcessMemoryDump> new_pmd(
         new ProcessMemoryDump(session_state, dump_args));
     iter = process_dumps.insert(std::make_pair(pid, std::move(new_pmd))).first;
   }
   return iter->second.get();
 }
 
-MemoryDumpManager::PeriodicGlobalDumpTimer::PeriodicGlobalDumpTimer() {}
+MemoryDumpManager::PeriodicGlobalDumpTimer::PeriodicGlobalDumpTimer(
+    MemoryDumpManager* mdm)
+    : mdm_(mdm) {}
 
 MemoryDumpManager::PeriodicGlobalDumpTimer::~PeriodicGlobalDumpTimer() {
   Stop();
 }
 
 void MemoryDumpManager::PeriodicGlobalDumpTimer::Start(
     const std::vector<TraceConfig::MemoryDumpConfig::Trigger>& triggers_list) {
   if (triggers_list.empty())
     return;
 
   // At the moment the periodic support is limited to at most one periodic
   // trigger per dump mode. All intervals should be an integer multiple of the
   // smallest interval specified.
   periodic_dumps_count_ = 0;
   uint32_t min_timer_period_ms = std::numeric_limits<uint32_t>::max();
   uint32_t light_dump_period_ms = 0;
   uint32_t heavy_dump_period_ms = 0;
   DCHECK_LE(triggers_list.size(), 3u);
   for (const TraceConfig::MemoryDumpConfig::Trigger& config : triggers_list) {
     DCHECK_NE(0u, config.periodic_interval_ms);
-    if (config.level_of_detail == MemoryDumpLevelOfDetail::LIGHT) {
-      DCHECK_EQ(0u, light_dump_period_ms);
-      light_dump_period_ms = config.periodic_interval_ms;
-    } else if (config.level_of_detail == MemoryDumpLevelOfDetail::DETAILED) {
-      DCHECK_EQ(0u, heavy_dump_period_ms);
-      heavy_dump_period_ms = config.periodic_interval_ms;
+    switch (config.level_of_detail) {
+      case MemoryDumpLevelOfDetail::BACKGROUND:
+        DCHECK(mdm_->IsDumpModeAllowed(MemoryDumpLevelOfDetail::BACKGROUND));
+        break;
+      case MemoryDumpLevelOfDetail::LIGHT:
+        DCHECK_EQ(0u, light_dump_period_ms);
+        DCHECK(mdm_->IsDumpModeAllowed(MemoryDumpLevelOfDetail::LIGHT));
+        light_dump_period_ms = config.periodic_interval_ms;
+        break;
+      case MemoryDumpLevelOfDetail::DETAILED:
+        DCHECK_EQ(0u, heavy_dump_period_ms);
+        DCHECK(mdm_->IsDumpModeAllowed(MemoryDumpLevelOfDetail::DETAILED));
+        heavy_dump_period_ms = config.periodic_interval_ms;
+        break;
     }
     min_timer_period_ms =
         std::min(min_timer_period_ms, config.periodic_interval_ms);
   }
 
   DCHECK_EQ(0u, light_dump_period_ms % min_timer_period_ms);
   light_dump_rate_ = light_dump_period_ms / min_timer_period_ms;
   DCHECK_EQ(0u, heavy_dump_period_ms % min_timer_period_ms);
   heavy_dump_rate_ = heavy_dump_period_ms / min_timer_period_ms;
 
@@ skipping 13 matching lines @@
 }
 
 void MemoryDumpManager::PeriodicGlobalDumpTimer::RequestPeriodicGlobalDump() {
   MemoryDumpLevelOfDetail level_of_detail = MemoryDumpLevelOfDetail::BACKGROUND;
   if (light_dump_rate_ > 0 && periodic_dumps_count_ % light_dump_rate_ == 0)
     level_of_detail = MemoryDumpLevelOfDetail::LIGHT;
   if (heavy_dump_rate_ > 0 && periodic_dumps_count_ % heavy_dump_rate_ == 0)
     level_of_detail = MemoryDumpLevelOfDetail::DETAILED;
   ++periodic_dumps_count_;
 
-  MemoryDumpManager::GetInstance()->RequestGlobalDump(
-      MemoryDumpType::PERIODIC_INTERVAL, level_of_detail);
+  mdm_->RequestGlobalDump(MemoryDumpType::PERIODIC_INTERVAL, level_of_detail);
 }
 
 }  // namespace trace_event
 }  // namespace base