Improve memory estimate of SpdySessionPool in net/ MemoryDumpProvider.

net/spdy/spdy_session.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/spdy/spdy_session.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
+#include "base/trace_event/memory_usage_estimator.h"
 #include "base/trace_event/trace_event.h"
 #include "base/values.h"
 #include "crypto/ec_private_key.h"
 #include "crypto/ec_signature_creator.h"
 #include "net/base/proxy_delegate.h"
 #include "net/cert/asn1_util.h"
 #include "net/cert/cert_verify_result.h"
 #include "net/cert/ct_policy_status.h"
 #include "net/http/http_log_util.h"
 #include "net/http/http_network_session.h"
@@ skipping 527 matching lines @@
 }
 
 base::WeakPtr<SpdyStream> SpdyStreamRequest::ReleaseStream() {
   DCHECK(!session_);
   base::WeakPtr<SpdyStream> stream = stream_;
   DCHECK(stream);
   Reset();
   return stream;
 }
 
+size_t SpdyStreamRequest::EstimateMemoryUsage() const {
+  return base::trace_event::EstimateItemMemoryUsage(url_);
+}
+
 void SpdyStreamRequest::OnRequestCompleteSuccess(
     const base::WeakPtr<SpdyStream>& stream) {
   DCHECK(session_);
   DCHECK(!stream_);
   DCHECK(!callback_.is_null());
   CompletionCallback callback = callback_;
   Reset();
   DCHECK(stream);
   stream_ = stream;
   callback.Run(OK);
@@ skipping 58 matching lines @@
     spdy_session_->pool_->RegisterUnclaimedPushedStream(
         url, spdy_session_->GetWeakPtr());
   }
   return streams_.insert(
       position,
       std::make_pair(
           url, SpdySession::UnclaimedPushedStreamContainer::PushedStreamInfo(
                    stream_id, creation_time)));
 }
 
+size_t SpdySession::UnclaimedPushedStreamContainer::EstimateMemoryUsage()
+    const {
+  return base::trace_event::EstimateMemoryUsage(streams_);
+}
+
 // static
 bool SpdySession::CanPool(TransportSecurityState* transport_security_state,
                           const SSLInfo& ssl_info,
                           const std::string& old_hostname,
                           const std::string& new_hostname) {
   // Pooling is prohibited if the server cert is not valid for the new domain,
   // and for connections on which client certs were sent. It is also prohibited
   // when channel ID was sent if the hosts are from different eTLDs+1.
   if (IsCertStatusError(ssl_info.cert_status))
     return false;
@@ skipping 402 matching lines @@
 bool SpdySession::CloseOneIdleConnection() {
   CHECK(!in_io_loop_);
   DCHECK(pool_);
   if (active_streams_.empty()) {
     DoDrainSession(ERR_CONNECTION_CLOSED, "Closing idle connection.");
   }
   // Return false as the socket wasn't immediately closed.
   return false;
 }
 
-void SpdySession::DumpMemoryStats(StreamSocket::SocketMemoryStats* stats,
-                                  bool* is_session_active) const {
+size_t SpdySession::DumpMemoryStats(StreamSocket::SocketMemoryStats* stats,
+                                    bool* is_session_active) const {
+  // TODO(xunjieli): Include |pending_create_stream_queues_| when WeakPtr is
+  // supported in memory_usage_estimator.h.
   *is_session_active = is_active();
   connection_->DumpMemoryStats(stats);
+  // |connection_| is estimated in stats->total_size. |read_buffer_| is
+  // estimated in kReadBufferSize. TODO(xunjieli): Make them use EMU().
+  return stats->total_size + kReadBufferSize +
+         base::trace_event::EstimateMemoryUsage(spdy_session_key_) +
+         base::trace_event::EstimateMemoryUsage(pooled_aliases_) +
+         base::trace_event::EstimateMemoryUsage(active_streams_) +
+         base::trace_event::EstimateMemoryUsage(unclaimed_pushed_streams_) +
+         base::trace_event::EstimateMemoryUsage(created_streams_) +
+         base::trace_event::EstimateMemoryUsage(write_queue_) +
+         base::trace_event::EstimateMemoryUsage(in_flight_write_) +
+         base::trace_event::EstimateMemoryUsage(buffered_spdy_framer_) +
+         base::trace_event::EstimateMemoryUsage(initial_settings_) +
+         base::trace_event::EstimateMemoryUsage(stream_send_unstall_queue_) +
+         base::trace_event::EstimateMemoryUsage(priority_dependency_state_);
 }
 
 void SpdySession::EnqueueStreamWrite(
     const base::WeakPtr<SpdyStream>& stream,
     SpdyFrameType frame_type,
     std::unique_ptr<SpdyBufferProducer> producer) {
   DCHECK(frame_type == HEADERS || frame_type == DATA);
   EnqueueWrite(stream->priority(), frame_type, std::move(producer), stream);
 }
 
@@ skipping 2040 matching lines @@
     if (!queue->empty()) {
       SpdyStreamId stream_id = queue->front();
       queue->pop_front();
       return stream_id;
     }
   }
   return 0;
 }
 
 }  // namespace net