Make HttpNetworkSession a client of memory coordinator

net/http/http_network_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_HTTP_HTTP_NETWORK_SESSION_H_
 #define NET_HTTP_HTTP_NETWORK_SESSION_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <set>
 #include <string>
 #include <unordered_set>
 #include <vector>
 
 #include "base/bind.h"
+#include "base/memory/memory_coordinator_client.h"
 #include "base/memory/memory_pressure_monitor.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/non_thread_safe.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/net_export.h"
 #include "net/dns/host_resolver.h"
 #include "net/http/http_auth_cache.h"
 #include "net/http/http_stream_factory.h"
 #include "net/quic/chromium/quic_stream_factory.h"
@@ skipping 27 matching lines @@
 class QuicServerInfoFactory;
 class SocketPerformanceWatcherFactory;
 class SOCKSClientSocketPool;
 class SSLClientSocketPool;
 class SSLConfigService;
 class TransportClientSocketPool;
 class TransportSecurityState;
 
 // This class holds session objects used by HttpNetworkTransaction objects.
 class NET_EXPORT HttpNetworkSession
-    : NON_EXPORTED_BASE(public base::NonThreadSafe) {
+    : NON_EXPORTED_BASE(public base::NonThreadSafe),
+      public base::MemoryCoordinatorClient {

[Ryan Sleevi, 2016/09/26 15:15:59]

Just from a design perspective, base::MemoryPressureListener seems like a safer
design pattern/paradigm.

That is, it automatically includes the de-registration aspect (when it goes out
of scope) and it avoids the need for public inheritance (by virtue of invoking
the callback).

The interface pattern is useful if we anticipate there being multiple methods a
memory coordinator client can have invoked, but if we just expect one (a state
transition), the callback approach seems to offer much better design decoupling.

We could easily imagine this being done by something like

class HttpNetworkSession {
 private:
  class Helper;

  void OnMemoryStateChange(base::MemoryState state);

  std::unique_ptr<Helper> helper_;
};

in .cc
class HttpNetworkSession::Helper {
 public:
  explicit Helper(const base::Callback<base::MemoryState>& callback) :
cb_(callback) {
   ClientRegistry->AddObserver(this);
  }
  ~Helper() {
   ClientRegistry->RemoveObserver(this);
  }

  void OnMemoryStateChange(base::MemoryState state) {
   cb_.Run(state);
  }
};



I mention this because I think having a bunch of classes inherit from
base::MemoryCoordinatorClient as part of their public interfaces probably isn't
what we want/desire long term, because that exposes the implementation detail
publicly, versus the MemoryPressureListener 'implementation detail' approach.

  public:
   struct NET_EXPORT Params {
     Params();
     Params(const Params& other);
     ~Params();
 
     ClientSocketFactory* client_socket_factory;
     HostResolver* host_resolver;
     CertVerifier* cert_verifier;
     ChannelIDService* channel_id_service;
@@ skipping 117 matching lines @@
     bool http_09_on_non_default_ports_enabled;
   };
 
   enum SocketPoolType {
     NORMAL_SOCKET_POOL,
     WEBSOCKET_SOCKET_POOL,
     NUM_SOCKET_POOL_TYPES
   };
 
   explicit HttpNetworkSession(const Params& params);
-  ~HttpNetworkSession();
+  ~HttpNetworkSession() override;
 
   HttpAuthCache* http_auth_cache() { return &http_auth_cache_; }
   SSLClientAuthCache* ssl_client_auth_cache() {
     return &ssl_client_auth_cache_;
   }
 
   void AddResponseDrainer(HttpResponseBodyDrainer* drainer);
 
   void RemoveResponseDrainer(HttpResponseBodyDrainer* drainer);
 
@@ skipping 59 matching lines @@
 
  private:
   friend class HttpNetworkSessionPeer;
 
   ClientSocketPoolManager* GetSocketPoolManager(SocketPoolType pool_type);
 
   // Flush sockets on low memory notifications callback.
   void OnMemoryPressure(
       base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level);
 
+  // base::MemoryCoordinatorClient implementation:
+  void OnMemoryStateChange(base::MemoryState state) override;
+
   NetLog* const net_log_;
   HttpServerProperties* const http_server_properties_;
   CertVerifier* const cert_verifier_;
   HttpAuthHandlerFactory* const http_auth_handler_factory_;
 
   // Not const since it's modified by HttpNetworkSessionPeer for testing.
   ProxyService* proxy_service_;
   const scoped_refptr<SSLConfigService> ssl_config_service_;
 
   HttpAuthCache http_auth_cache_;
@@ skipping 10 matching lines @@
   bool enabled_protocols_[NUM_VALID_ALTERNATE_PROTOCOLS];
 
   Params params_;
 
   std::unique_ptr<base::MemoryPressureListener> memory_pressure_listener_;
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_NETWORK_SESSION_H_