memory-infra: Fill the memory dump callback result (2/2)

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/allocator/features.h"
@@ skipping 74 matching lines @@
   TRACE_EVENT_NESTABLE_ASYNC_END1(
       MemoryDumpManager::kTraceCategory, "GlobalMemoryDump",
       TRACE_ID_MANGLE(dump_guid), "success", success);
 
   if (!wrapped_callback.is_null()) {
     wrapped_callback.Run(dump_guid, success);
     wrapped_callback.Reset();
   }
 }
 
+void FillOsDumpFromProcessMemoryDump(
+    MemoryDumpCallbackResult::OSMemDump& osDump,

[Primiano Tucci (use gerrit), 2017/04/03 08:49:27]

output arguments should:
1. use pointers, not references. references can be used only for input.
Specifically our style guide says:
"All parameters passed by reference must be labeled const." [1]
2. be at the end of the argument list "When ordering function parameters, put
all input-only parameters before any output parameters." [2]

On top of this, when you pass input arguments as pointers, I find "const" to
still help readability
Also variables/args should be lower_with_under [3] (osDump -> os_dump)

so this should be:
FillOsDumpFromProcessMemoryDump(const ProcessMemoryDump* pmd,
MemoryDumpCallbackResult::OSMemDump* os_dump) {
...
}


[1] https://google.github.io/styleguide/cppguide.html#Reference_Arguments
[2]
https://google.github.io/styleguide/cppguide.html#Function_Parameter_Ordering
[3] https://google.github.io/styleguide/cppguide.html#Variable_Names

+    ProcessMemoryDump* pmd) {
+  if (pmd->has_process_totals()) {
+    auto* totals = pmd->process_totals();

[Primiano Tucci (use gerrit), 2017/04/03 08:49:27]

minor thing about "auto". There are no official rules on this, but my rule of
thumb is that if the explicit type fits still in one line (80 cols) I find the
overall code more readable / codesearcheable. Here I'd do

const ProcessMemoryTotals* totals = pmd->process_totals();

+    osDump.resident_set_kb = totals->resident_set_bytes() / 1024;
+  }
+}
+
 // Proxy class which wraps a ConvertableToTraceFormat owned by the
 // |session_state| into a proxy object that can be added to the trace event log.
 // This is to solve the problem that the MemoryDumpSessionState is refcounted
 // but the tracing subsystem wants a std::unique_ptr<ConvertableToTraceFormat>.
 template <typename T>
 struct SessionStateConvertableProxy : public ConvertableToTraceFormat {
   using GetterFunctPtr = T* (MemoryDumpSessionState::*)() const;
 
   SessionStateConvertableProxy(
       scoped_refptr<MemoryDumpSessionState> session_state,
@@ skipping 686 matching lines @@
           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 =
           GetDumpsSumKb("partition_alloc/partitions/*", process_memory_dump);
       result.chrome_dump.blink_gc_total_kb =
           GetDumpsSumKb("blink_gc", process_memory_dump);
+      FillOsDumpFromProcessMemoryDump(result.os_dump, process_memory_dump);
+    } else {
+      auto& os_dump = result.extra_processes_dump[pid];
+      FillOsDumpFromProcessMemoryDump(os_dump, process_memory_dump);
     }
   }
 
   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";
   }
@@ skipping 192 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