Improve memory estimate of SpdySessionPool in net/ MemoryDumpProvider.

net/spdy/spdy_session.h

 // 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.
 
 #ifndef NET_SPDY_SPDY_SESSION_H_
 #define NET_SPDY_SPDY_SESSION_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 173 matching lines @@
   // Cancels any pending stream creation request. May be called
   // repeatedly.
   void CancelRequest();
 
   // Transfers the created stream (guaranteed to not be NULL) to the
   // caller. Must be called at most once after StartRequest() returns
   // OK or |callback| is called with OK. The caller must immediately
   // set a delegate for the returned stream (except for test code).
   base::WeakPtr<SpdyStream> ReleaseStream();
 
+  // Returns the estimate of dynamically allocated memory in bytes.
+  size_t EstimateMemoryUsage() const;
+
  private:
   friend class SpdySession;
 
   // Called by |session_| when the stream attempt has finished
   // successfully.
   void OnRequestCompleteSuccess(const base::WeakPtr<SpdyStream>& stream);
 
   // Called by |session_| when the stream attempt has finished with an
   // error. Also called with ERR_ABORTED if |session_| is destroyed
   // while the stream attempt is still pending.
@@ skipping 31 matching lines @@
   // Container class for unclaimed pushed streams on a SpdySession.  Guarantees
   // that |spdy_session_.pool_| gets notified every time a stream is pushed or
   // an unclaimed pushed stream is claimed.
   class UnclaimedPushedStreamContainer {
    public:
     struct PushedStreamInfo {
       PushedStreamInfo() : stream_id(0) {}
       PushedStreamInfo(SpdyStreamId stream_id, base::TimeTicks creation_time)
           : stream_id(stream_id), creation_time(creation_time) {}
       ~PushedStreamInfo() {}
+      size_t EstimateMemoryUsage() const { return 0; }
 
       SpdyStreamId stream_id;
       base::TimeTicks creation_time;
     };
     using PushedStreamMap = std::map<GURL, PushedStreamInfo>;
     using iterator = PushedStreamMap::iterator;
     using const_iterator = PushedStreamMap::const_iterator;
 
     UnclaimedPushedStreamContainer() = delete;
     explicit UnclaimedPushedStreamContainer(SpdySession* spdy_session);
     ~UnclaimedPushedStreamContainer();
 
     bool empty() const { return streams_.empty(); }
     size_t size() const { return streams_.size(); }
     const_iterator begin() const { return streams_.begin(); }
     const_iterator end() const { return streams_.end(); }
     const_iterator find(const GURL& url) const { return streams_.find(url); }
     size_t count(const GURL& url) const { return streams_.count(url); }
     const_iterator lower_bound(const GURL& url) const {
       return streams_.lower_bound(url);
     }
 
     size_t erase(const GURL& url);
     iterator erase(const_iterator it);
     iterator insert(const_iterator position,
                     const GURL& url,
                     SpdyStreamId stream_id,
                     const base::TimeTicks& creation_time);
 
+    size_t EstimateMemoryUsage() const;
+
    private:
     SpdySession* spdy_session_;
 
     // (Bijective) map from the URL to the ID of the streams that have
     // already started to be pushed by the server, but do not have
     // consumers yet. Contains a subset of |active_streams_|.
     PushedStreamMap streams_;
   };
 
   // Returns true if |new_hostname| can be pooled into an existing connection to
@@ skipping 274 matching lines @@
   // Must be used only by |pool_|.
   base::WeakPtr<SpdySession> GetWeakPtr();
 
   // HigherLayeredPool implementation:
   bool CloseOneIdleConnection() override;
 
   // Dumps memory allocation stats to |stats|. Sets |*is_session_active| to
   // indicate whether session is active.
   // |stats| can be assumed as being default initialized upon entry.
   // Implementation overrides fields in |stats|.
-  void DumpMemoryStats(StreamSocket::SocketMemoryStats* stats,
-                       bool* is_session_active) const;
+  // Returns the estimate of dynamically allocated memory in bytes, which
+  // includes the size attributed to the underlying socket.
+  size_t DumpMemoryStats(StreamSocket::SocketMemoryStats* stats,
+                         bool* is_session_active) const;
 
  private:
   friend class test::SpdyStreamTest;
   friend class base::RefCounted<SpdySession>;
   friend class HttpNetworkTransactionTest;
   friend class HttpProxyClientSocketPoolTest;
   friend class SpdyHttpStreamTest;
   friend class SpdyNetworkTransactionTest;
   friend class SpdyProxyClientSocketTest;
   friend class SpdySessionTest;
@@ skipping 631 matching lines @@
   // Used for posting asynchronous IO tasks.  We use this even though
   // SpdySession is refcounted because we don't need to keep the SpdySession
   // alive if the last reference is within a RunnableMethod.  Just revoke the
   // method.
   base::WeakPtrFactory<SpdySession> weak_factory_;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_SESSION_H_