[tracing] Add browser-side test for memory dumps.

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 "base/atomic_sequence_num.h"
 #include "base/compiler_specific.h"
@@ skipping 93 matching lines @@
   // UnregisterDumpProvider is called while the trace is enabled.
   it = std::find(dump_providers_enabled_.begin(), dump_providers_enabled_.end(),
                  mdp);
   if (it != dump_providers_enabled_.end())
     dump_providers_enabled_.erase(it);
 }
 
 void MemoryDumpManager::RequestGlobalDump(
     MemoryDumpType dump_type,
     const MemoryDumpCallback& callback) {
+  LOG(ERROR) << "MDM request enabled="
+             << subtle::NoBarrier_Load(&memory_tracing_enabled_);
   // Bail out immediately if tracing is not enabled at all.
   if (!UNLIKELY(subtle::NoBarrier_Load(&memory_tracing_enabled_)))
     return;
 
   // TODO(primiano): Make guid actually unique (cross-process) by hashing it
   // with the PID. See crbug.com/462931 for details.
   const uint64 guid = g_next_guid.GetNext();
 
   // The delegate_ is supposed to be thread safe, immutable and long lived.
   // No need to keep the lock after we ensure that a delegate has been set.
   MemoryDumpManagerDelegate* delegate;
   {
     AutoLock lock(lock_);
     delegate = delegate_;
   }
 
+  LOG(ERROR) << "MDM request " << guid << " delegate : " << (void*)delegate;
   if (delegate) {
     // The delegate is in charge to coordinate the request among all the
     // processes and call the CreateLocalDumpPoint on the local process.
     MemoryDumpRequestArgs args = {guid, dump_type};
     delegate->RequestGlobalMemoryDump(args, callback);
   } else if (!callback.is_null()) {
     callback.Run(guid, false /* success */);
   }
 }
 
 void MemoryDumpManager::RequestGlobalDump(MemoryDumpType dump_type) {
   RequestGlobalDump(dump_type, MemoryDumpCallback());
 }
 
 // Creates a memory dump for the current process and appends it to the trace.
 void MemoryDumpManager::CreateProcessDump(
     const MemoryDumpRequestArgs& args) {
+  LOG(ERROR) << "MDM create " << args.dump_guid;
   bool did_any_provider_dump = false;
   scoped_ptr<ProcessMemoryDump> pmd(new ProcessMemoryDump());
 
   // Serialize dump generation so that memory dump providers don't have to deal
   // with thread safety.
   {
     AutoLock lock(lock_);
     for (auto it = dump_providers_enabled_.begin();
          it != dump_providers_enabled_.end();) {
       dump_provider_currently_active_ = *it;
@@ skipping 29 matching lines @@
 }
 
 void MemoryDumpManager::OnTraceLogEnabled() {
   // TODO(primiano): at this point we query  TraceLog::GetCurrentCategoryFilter
   // to figure out (and cache) which dumpers should be enabled or not.
   // For the moment piggy back everything on the generic "memory" category.
   bool enabled;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(kTraceCategory, &enabled);
 
   AutoLock lock(lock_);
+  LOG(ERROR) << "OnTraceLogEnabled " << enabled;
   if (enabled) {
     dump_providers_enabled_.assign(dump_providers_registered_.begin(),
                                    dump_providers_registered_.end());
   } else {
     dump_providers_enabled_.clear();
   }
   subtle::NoBarrier_Store(&memory_tracing_enabled_, 1);
 }
 
 void MemoryDumpManager::OnTraceLogDisabled() {
+  LOG(ERROR) << "OnTraceLogDisabled";
   AutoLock lock(lock_);
   dump_providers_enabled_.clear();
   subtle::NoBarrier_Store(&memory_tracing_enabled_, 0);
 }
 
 }  // namespace trace_event
 }  // namespace base