Revert of [Memory UMA] Return the extra_processes_dump map as part of the ResponseCallback

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 <inttypes.h>
 #include <stdio.h>
 
 #include <algorithm>
@@ skipping 724 matching lines @@
     callback_task_runner->PostTask(
         FROM_HERE, BindOnce(&MemoryDumpManager::FinalizeDumpAndAddToTrace,
                             Passed(&pmd_async_state)));
     return;
   }
 
   TRACE_EVENT0(kTraceCategory, "MemoryDumpManager::FinalizeDumpAndAddToTrace");
 
   // The results struct to fill.
   // TODO(hjd): Transitional until we send the full PMD. See crbug.com/704203
-  base::Optional<MemoryDumpCallbackResult> result;
+  base::Optional<MemoryDumpCallbackResult> result_opt;
+
   for (const auto& kv : pmd_async_state->process_dumps) {
     ProcessId pid = kv.first;  // kNullProcessId for the current process.
     ProcessMemoryDump* process_memory_dump = kv.second.get();
     std::unique_ptr<TracedValue> traced_value(new TracedValue);
     process_memory_dump->AsValueInto(traced_value.get());
     traced_value->SetString("level_of_detail",
                             MemoryDumpLevelOfDetailToString(
                                 pmd_async_state->req_args.level_of_detail));
     const char* const event_name =
         MemoryDumpTypeToString(pmd_async_state->req_args.dump_type);
 
     std::unique_ptr<ConvertableToTraceFormat> event_value(
         std::move(traced_value));
     TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_PROCESS_ID(
         TRACE_EVENT_PHASE_MEMORY_DUMP,
         TraceLog::GetCategoryGroupEnabled(kTraceCategory), event_name,
         trace_event_internal::kGlobalScope, dump_guid, pid,
         kTraceEventNumArgs, kTraceEventArgNames,
         kTraceEventArgTypes, nullptr /* arg_values */, &event_value,
         TRACE_EVENT_FLAG_HAS_ID);
 
     // TODO(hjd): Transitional until we send the full PMD. See crbug.com/704203
     // Don't try to fill the struct in detailed mode since it is hard to avoid
     // double counting.
     if (pmd_async_state->req_args.level_of_detail ==
         MemoryDumpLevelOfDetail::DETAILED)
       continue;
-    if (!result.has_value())
-      result = MemoryDumpCallbackResult();
+    MemoryDumpCallbackResult result;
     // TODO(hjd): Transitional until we send the full PMD. See crbug.com/704203
     if (pid == kNullProcessId) {
-      result->chrome_dump.malloc_total_kb =
+      result.chrome_dump.malloc_total_kb =
           GetDumpsSumKb("malloc", process_memory_dump);
-      result->chrome_dump.v8_total_kb =
+      result.chrome_dump.v8_total_kb =
           GetDumpsSumKb("v8/*", process_memory_dump);
 
       // partition_alloc reports sizes for both allocated_objects and
       // partitions. The memory allocated_objects uses is a subset of
       // the partitions memory so to avoid double counting we only
       // count partitions memory.
-      result->chrome_dump.partition_alloc_total_kb =
+      result.chrome_dump.partition_alloc_total_kb =
           GetDumpsSumKb("partition_alloc/partitions/*", process_memory_dump);
-      result->chrome_dump.blink_gc_total_kb =
+      result.chrome_dump.blink_gc_total_kb =
           GetDumpsSumKb("blink_gc", process_memory_dump);
-      FillOsDumpFromProcessMemoryDump(process_memory_dump, &result->os_dump);
+      FillOsDumpFromProcessMemoryDump(process_memory_dump, &result.os_dump);
     } else {
-      auto& os_dump = result->extra_processes_dump[pid];
+      auto& os_dump = result.extra_processes_dump[pid];
       FillOsDumpFromProcessMemoryDump(process_memory_dump, &os_dump);
     }
+    result_opt = result;
   }
 
   bool tracing_still_enabled;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(kTraceCategory, &tracing_still_enabled);
   if (!tracing_still_enabled) {
     pmd_async_state->dump_successful = false;
     VLOG(1) << kLogPrefix << " failed because tracing was disabled before"
             << " the dump was completed";
   }
 
   if (!pmd_async_state->callback.is_null()) {
     pmd_async_state->callback.Run(dump_guid, pmd_async_state->dump_successful,
-                                  result);
+                                  result_opt);
     pmd_async_state->callback.Reset();
   }
 
   TRACE_EVENT_NESTABLE_ASYNC_END0(kTraceCategory, "ProcessMemoryDump",
                                   TRACE_ID_LOCAL(dump_guid));
 }
 
 void MemoryDumpManager::OnTraceLogEnabled() {
   bool enabled;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(kTraceCategory, &enabled);
@@ skipping 155 matching lines @@
   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();
 }
 
 }  // namespace trace_event
 }  // namespace base