Track STL containers in QuicStreamFactory::DumpMemoryStats

net/http/disk_cache_based_quic_server_info.cc

 // Copyright 2014 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/http/disk_cache_based_quic_server_info.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
+#include "base/trace_event/memory_usage_estimator.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_network_session.h"
 #include "net/quic/core/quic_server_id.h"
 
 namespace net {
 
 // Some APIs inside disk_cache take a handle that the caller must keep alive
@@ skipping 155 matching lines @@
 
   RecordQuicServerInfoStatus(QUIC_SERVER_INFO_EXTERNAL_CACHE_HIT);
   if (!backend_) {
     RecordQuicServerInfoFailure(PERSIST_NO_BACKEND_FAILURE);
     return;
   }
 
   backend_->OnExternalCacheHit(key());
 }
 
+size_t DiskCacheBasedQuicServerInfo::EstimateMemoryUsage() const {
+  return base::trace_event::EstimateMemoryUsage(new_data_) +
+         base::trace_event::EstimateMemoryUsage(pending_write_data_) +
+         base::trace_event::EstimateMemoryUsage(server_id_) +
+         (read_buffer_ == nullptr ? 0 : read_buffer_->size()) +
+         (write_buffer_ == nullptr ? 0 : write_buffer_->size()) +
+         base::trace_event::EstimateMemoryUsage(data_);
+}
+
 std::string DiskCacheBasedQuicServerInfo::key() const {
   return "quicserverinfo:" + server_id_.ToString();
 }
 
 void DiskCacheBasedQuicServerInfo::OnIOComplete(CacheOperationDataShim* unused,
                                                 int rv) {
   DCHECK_NE(NONE, state_);
   rv = DoLoop(rv);
   if (rv == ERR_IO_PENDING)
     return;
@@ skipping 130 matching lines @@
   return backend_->OpenEntry(key(), &data_shim_->entry, io_callback_);
 }
 
 int DiskCacheBasedQuicServerInfo::DoRead() {
   const int32_t size = entry_->GetDataSize(0 /* index */);
   if (!size) {
     state_ = WAIT_FOR_DATA_READY_DONE;
     return OK;
   }
 
-  read_buffer_ = new IOBuffer(size);
+  read_buffer_ = new IOBufferWithSize(size);
   state_ = READ_COMPLETE;
   return entry_->ReadData(
       0 /* index */, 0 /* offset */, read_buffer_.get(), size, io_callback_);
 }
 
 int DiskCacheBasedQuicServerInfo::DoWrite() {
-  write_buffer_ = new IOBuffer(new_data_.size());
+  write_buffer_ = new IOBufferWithSize(new_data_.size());
   memcpy(write_buffer_->data(), new_data_.data(), new_data_.size());
   state_ = WRITE_COMPLETE;
 
   return entry_->WriteData(0 /* index */,
                            0 /* offset */,
                            write_buffer_.get(),
                            new_data_.size(),
                            io_callback_,
                            true /* truncate */);
 }
@@ skipping 75 matching lines @@
   } else if (backend_->GetCacheType() == MEMORY_CACHE) {
     UMA_HISTOGRAM_ENUMERATION("Net.QuicDiskCache.FailureReason.MemoryCache",
                               failure, NUM_OF_FAILURES);
   } else {
     UMA_HISTOGRAM_ENUMERATION("Net.QuicDiskCache.FailureReason.DiskCache",
                               failure, NUM_OF_FAILURES);
   }
 }
 
 }  // namespace net