Avoid creating MemoryAllocatorDump for individual sockets

net/socket/client_socket_pool_base.cc

 // Copyright (c) 2012 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 "net/socket/client_socket_pool_base.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/compiler_specific.h"
@@ skipping 688 matching lines @@
   }
   dict->Set("groups", all_groups_dict);
   return dict;
 }
 
 void ClientSocketPoolBaseHelper::DumpMemoryStats(
     base::trace_event::ProcessMemoryDump* pmd,
     const std::string& parent_dump_absolute_name) const {
   base::trace_event::MemoryAllocatorDump* socket_pool_dump = nullptr;
   size_t socket_count = 0;
+  size_t total_size = 0;
+  size_t buffer_size = 0;
+  size_t cert_count = 0;
+  size_t serialized_cert_size = 0;
+  StreamSocket::SocketMemoryStats aggregated_stats;

[eroman, 2017/01/11 02:19:58]

Were you intending to use |aggregated_stats| in place of {total_size,
buffer_size, cert_count, serialized_cert_size} ?

Because it looks like that variable is unused right now.

[xunjieli, 2017/01/11 20:05:07]

Done. Good catch! sorry about that.

   for (const auto& kv : group_map_) {
     for (const auto& socket : kv.second->idle_sockets()) {
       // Only create a MemoryAllocatorDump if there is at least one idle socket
       if (!socket_pool_dump) {

[eroman, 2017/01/11 02:19:58]

I think it would make sense to extract this outside of the loop and keep all of
the code that creates and writes to socket_pool_dump there.

How about:

if (socket_count > 0) {
  base::trace_event::MemoryAllocatorDump* socket_pool_dump =
pmd->CreateAllocatorDump(...);
  socket_pool_dump->AddScalar(...)
   ...
}

[xunjieli, 2017/01/11 20:05:07]

Done. Thanks!

         socket_pool_dump = pmd->CreateAllocatorDump(base::StringPrintf(
             "%s/socket_pool", parent_dump_absolute_name.c_str()));
       }
-      socket.socket->DumpMemoryStats(pmd, socket_pool_dump->absolute_name());
+      StreamSocket::SocketMemoryStats stats;
+      socket.socket->DumpMemoryStats(&stats);
+      total_size += stats.total_size;
+      buffer_size += stats.buffer_size;
+      cert_count += stats.cert_count;
+      serialized_cert_size += stats.serialized_cert_size;
       ++socket_count;
     }
   }
   if (socket_pool_dump) {
     socket_pool_dump->AddScalar(
+        base::trace_event::MemoryAllocatorDump::kNameSize,
+        base::trace_event::MemoryAllocatorDump::kUnitsBytes, total_size);
+    socket_pool_dump->AddScalar(
         base::trace_event::MemoryAllocatorDump::kNameObjectCount,
         base::trace_event::MemoryAllocatorDump::kUnitsObjects, socket_count);
+    socket_pool_dump->AddScalar(
+        "buffer_size", base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+        buffer_size);
+    socket_pool_dump->AddScalar(
+        "cert_count", base::trace_event::MemoryAllocatorDump::kUnitsObjects,
+        cert_count);
+    socket_pool_dump->AddScalar(
+        "serialized_cert_size",
+        base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+        serialized_cert_size);
   }
 }
 
 bool ClientSocketPoolBaseHelper::IdleSocket::IsUsable() const {
   if (socket->WasEverUsed())
     return socket->IsConnectedAndIdle();
   return socket->IsConnected();
 }
 
 void ClientSocketPoolBaseHelper::CleanupIdleSockets(bool force) {
@@ skipping 674 matching lines @@
   // If there are no more requests, kill the backup timer.
   if (pending_requests_.empty())
     backup_job_timer_.Stop();
   request->CrashIfInvalid();
   return request;
 }
 
 }  // namespace internal
 
 }  // namespace net