Split net/spdy into core and chromium subdirectories.

net/spdy/spdy_session_pool.cc

Index: net/spdy/spdy_session_pool.cc
diff --git a/net/spdy/spdy_session_pool.cc b/net/spdy/spdy_session_pool.cc
deleted file mode 100644
index 4f12a2f5e29e6d46368f39b1edb4554a6ad330e5..0000000000000000000000000000000000000000
--- a/net/spdy/spdy_session_pool.cc
+++ /dev/null
@@ -1,514 +0,0 @@
-// 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_pool.h"
-
-#include <utility>
-
-#include "base/logging.h"
-#include "base/memory/ptr_util.h"
-#include "base/metrics/histogram_macros.h"
-#include "base/profiler/scoped_tracker.h"
-#include "base/stl_util.h"
-#include "base/trace_event/memory_allocator_dump.h"
-#include "base/trace_event/process_memory_dump.h"
-#include "base/trace_event/trace_event.h"
-#include "base/values.h"
-#include "net/base/address_list.h"
-#include "net/base/trace_constants.h"
-#include "net/http/http_network_session.h"
-#include "net/http/http_server_properties.h"
-#include "net/log/net_log_event_type.h"
-#include "net/log/net_log_source.h"
-#include "net/log/net_log_with_source.h"
-#include "net/spdy/hpack/hpack_constants.h"
-#include "net/spdy/hpack/hpack_huffman_table.h"
-#include "net/spdy/hpack/hpack_static_table.h"
-#include "net/spdy/platform/api/spdy_estimate_memory_usage.h"
-#include "net/spdy/platform/api/spdy_string_utils.h"
-#include "net/spdy/spdy_session.h"
-
-namespace net {
-
-namespace {
-
-enum SpdySessionGetTypes {
-  CREATED_NEW                 = 0,
-  FOUND_EXISTING              = 1,
-  FOUND_EXISTING_FROM_IP_POOL = 2,
-  IMPORTED_FROM_SOCKET        = 3,
-  SPDY_SESSION_GET_MAX        = 4
-};
-
-}  // namespace
-
-SpdySessionPool::SpdySessionPool(
-    HostResolver* resolver,
-    SSLConfigService* ssl_config_service,
-    HttpServerProperties* http_server_properties,
-    TransportSecurityState* transport_security_state,
-    bool enable_ping_based_connection_checking,
-    size_t session_max_recv_window_size,
-    const SettingsMap& initial_settings,
-    SpdySessionPool::TimeFunc time_func,
-    ProxyDelegate* proxy_delegate)
-    : http_server_properties_(http_server_properties),
-      transport_security_state_(transport_security_state),
-      ssl_config_service_(ssl_config_service),
-      resolver_(resolver),
-      enable_sending_initial_data_(true),
-      enable_ping_based_connection_checking_(
-          enable_ping_based_connection_checking),
-      session_max_recv_window_size_(session_max_recv_window_size),
-      initial_settings_(initial_settings),
-      time_func_(time_func),
-      push_delegate_(nullptr),
-      proxy_delegate_(proxy_delegate) {
-  NetworkChangeNotifier::AddIPAddressObserver(this);
-  if (ssl_config_service_.get())
-    ssl_config_service_->AddObserver(this);
-  CertDatabase::GetInstance()->AddObserver(this);
-}
-
-SpdySessionPool::~SpdySessionPool() {
-  CloseAllSessions();
-
-  while (!sessions_.empty()) {
-    // Destroy sessions to enforce that lifetime is scoped to SpdySessionPool.
-    // Write callbacks queued upon session drain are not invoked.
-    RemoveUnavailableSession((*sessions_.begin())->GetWeakPtr());
-  }
-
-  if (ssl_config_service_.get())
-    ssl_config_service_->RemoveObserver(this);
-  NetworkChangeNotifier::RemoveIPAddressObserver(this);
-  CertDatabase::GetInstance()->RemoveObserver(this);
-}
-
-base::WeakPtr<SpdySession> SpdySessionPool::CreateAvailableSessionFromSocket(
-    const SpdySessionKey& key,
-    std::unique_ptr<ClientSocketHandle> connection,
-    const NetLogWithSource& net_log,
-    bool is_secure) {
-  TRACE_EVENT0(kNetTracingCategory,
-               "SpdySessionPool::CreateAvailableSessionFromSocket");
-
-  UMA_HISTOGRAM_ENUMERATION(
-      "Net.SpdySessionGet", IMPORTED_FROM_SOCKET, SPDY_SESSION_GET_MAX);
-
-  auto new_session = base::MakeUnique<SpdySession>(
-      key, http_server_properties_, transport_security_state_,
-      enable_sending_initial_data_, enable_ping_based_connection_checking_,
-      session_max_recv_window_size_, initial_settings_, time_func_,
-      push_delegate_, proxy_delegate_, net_log.net_log());
-
-  new_session->InitializeWithSocket(std::move(connection), this, is_secure);
-
-  base::WeakPtr<SpdySession> available_session = new_session->GetWeakPtr();
-  sessions_.insert(new_session.release());
-  MapKeyToAvailableSession(key, available_session);
-
-  net_log.AddEvent(
-      NetLogEventType::HTTP2_SESSION_POOL_IMPORTED_SESSION_FROM_SOCKET,
-      available_session->net_log().source().ToEventParametersCallback());
-
-  // Look up the IP address for this session so that we can match
-  // future sessions (potentially to different domains) which can
-  // potentially be pooled with this one. Because GetPeerAddress()
-  // reports the proxy's address instead of the origin server, check
-  // to see if this is a direct connection.
-  if (key.proxy_server().is_direct()) {
-    IPEndPoint address;
-    if (available_session->GetPeerAddress(&address) == OK)
-      aliases_[address] = key;
-  }
-
-  return available_session;
-}
-
-base::WeakPtr<SpdySession> SpdySessionPool::FindAvailableSession(
-    const SpdySessionKey& key,
-    const GURL& url,
-    bool enable_ip_based_pooling,
-    const NetLogWithSource& net_log) {
-  UnclaimedPushedStreamMap::iterator url_it =
-      unclaimed_pushed_streams_.find(url);
-  if (!url.is_empty() && url_it != unclaimed_pushed_streams_.end()) {
-    DCHECK(url.SchemeIsCryptographic());
-    for (WeakSessionList::iterator it = url_it->second.begin();
-         it != url_it->second.end();) {
-      base::WeakPtr<SpdySession> spdy_session = *it;
-      // Lazy deletion of destroyed SpdySessions.
-      if (!spdy_session) {
-        it = url_it->second.erase(it);
-        continue;
-      }
-      ++it;
-      const SpdySessionKey& spdy_session_key = spdy_session->spdy_session_key();
-      if (!(spdy_session_key.proxy_server() == key.proxy_server()) ||
-          !(spdy_session_key.privacy_mode() == key.privacy_mode())) {
-        continue;
-      }
-      if (!spdy_session->VerifyDomainAuthentication(
-              key.host_port_pair().host())) {
-        continue;
-      }
-      return spdy_session;
-    }
-    if (url_it->second.empty()) {
-      unclaimed_pushed_streams_.erase(url_it);
-    }
-  }
-
-  AvailableSessionMap::iterator it = LookupAvailableSessionByKey(key);
-  if (it != available_sessions_.end()) {
-    if (key.Equals(it->second->spdy_session_key())) {
-      UMA_HISTOGRAM_ENUMERATION("Net.SpdySessionGet", FOUND_EXISTING,
-                                SPDY_SESSION_GET_MAX);
-      net_log.AddEvent(
-          NetLogEventType::HTTP2_SESSION_POOL_FOUND_EXISTING_SESSION,
-          it->second->net_log().source().ToEventParametersCallback());
-    } else {
-      if (!enable_ip_based_pooling) {
-        // Remove session from available sessions and from aliases, and remove
-        // key from the session's pooled alias set, so that a new session can be
-        // created with this |key|.
-        it->second->RemovePooledAlias(key);
-        UnmapKey(key);
-        RemoveAliases(key);
-        return base::WeakPtr<SpdySession>();
-      }
-
-      UMA_HISTOGRAM_ENUMERATION("Net.SpdySessionGet",
-                                FOUND_EXISTING_FROM_IP_POOL,
-                                SPDY_SESSION_GET_MAX);
-      net_log.AddEvent(
-          NetLogEventType::
-              HTTP2_SESSION_POOL_FOUND_EXISTING_SESSION_FROM_IP_POOL,
-          it->second->net_log().source().ToEventParametersCallback());
-    }
-    return it->second;
-  }
-
-  if (!enable_ip_based_pooling)
-    return base::WeakPtr<SpdySession>();
-
-  // Look up IP addresses from resolver cache.
-  HostResolver::RequestInfo resolve_info(key.host_port_pair());
-  AddressList addresses;
-  int rv = resolver_->ResolveFromCache(resolve_info, &addresses, net_log);
-  DCHECK_NE(rv, ERR_IO_PENDING);
-  if (rv != OK)
-    return base::WeakPtr<SpdySession>();
-
-  // Check if we have a session through a domain alias.
-  for (AddressList::const_iterator address_it = addresses.begin();
-       address_it != addresses.end();
-       ++address_it) {
-    AliasMap::const_iterator alias_it = aliases_.find(*address_it);
-    if (alias_it == aliases_.end())
-      continue;
-
-    // We found an alias.
-    const SpdySessionKey& alias_key = alias_it->second;
-
-    // We can reuse this session only if the proxy and privacy
-    // settings match.
-    if (!(alias_key.proxy_server() == key.proxy_server()) ||
-        !(alias_key.privacy_mode() == key.privacy_mode()))
-      continue;
-
-    AvailableSessionMap::iterator available_session_it =
-        LookupAvailableSessionByKey(alias_key);
-    if (available_session_it == available_sessions_.end()) {
-      NOTREACHED();  // It shouldn't be in the aliases table if we can't get it!
-      continue;
-    }
-
-    const base::WeakPtr<SpdySession>& available_session =
-        available_session_it->second;
-    DCHECK(base::ContainsKey(sessions_, available_session.get()));
-    // If the session is a secure one, we need to verify that the
-    // server is authenticated to serve traffic for |host_port_proxy_pair| too.
-    if (!available_session->VerifyDomainAuthentication(
-            key.host_port_pair().host())) {
-      UMA_HISTOGRAM_ENUMERATION("Net.SpdyIPPoolDomainMatch", 0, 2);
-      continue;
-    }
-
-    UMA_HISTOGRAM_ENUMERATION("Net.SpdyIPPoolDomainMatch", 1, 2);
-    UMA_HISTOGRAM_ENUMERATION("Net.SpdySessionGet",
-                              FOUND_EXISTING_FROM_IP_POOL,
-                              SPDY_SESSION_GET_MAX);
-    net_log.AddEvent(
-        NetLogEventType::HTTP2_SESSION_POOL_FOUND_EXISTING_SESSION_FROM_IP_POOL,
-        available_session->net_log().source().ToEventParametersCallback());
-    // Add this session to the map so that we can find it next time.
-    MapKeyToAvailableSession(key, available_session);
-    available_session->AddPooledAlias(key);
-    return available_session;
-  }
-
-  return base::WeakPtr<SpdySession>();
-}
-
-void SpdySessionPool::MakeSessionUnavailable(
-    const base::WeakPtr<SpdySession>& available_session) {
-  UnmapKey(available_session->spdy_session_key());
-  RemoveAliases(available_session->spdy_session_key());
-  const std::set<SpdySessionKey>& aliases = available_session->pooled_aliases();
-  for (std::set<SpdySessionKey>::const_iterator it = aliases.begin();
-       it != aliases.end(); ++it) {
-    UnmapKey(*it);
-    RemoveAliases(*it);
-  }
-  DCHECK(!IsSessionAvailable(available_session));
-}
-
-void SpdySessionPool::RemoveUnavailableSession(
-    const base::WeakPtr<SpdySession>& unavailable_session) {
-  DCHECK(!IsSessionAvailable(unavailable_session));
-
-  unavailable_session->net_log().AddEvent(
-      NetLogEventType::HTTP2_SESSION_POOL_REMOVE_SESSION);
-
-  SessionSet::iterator it = sessions_.find(unavailable_session.get());
-  CHECK(it != sessions_.end());
-  std::unique_ptr<SpdySession> owned_session(*it);
-  sessions_.erase(it);
-}
-
-// Make a copy of |sessions_| in the Close* functions below to avoid
-// reentrancy problems. Since arbitrary functions get called by close
-// handlers, it doesn't suffice to simply increment the iterator
-// before closing.
-
-void SpdySessionPool::CloseCurrentSessions(Error error) {
-  CloseCurrentSessionsHelper(error, "Closing current sessions.",
-                             false /* idle_only */);
-}
-
-void SpdySessionPool::CloseCurrentIdleSessions() {
-  CloseCurrentSessionsHelper(ERR_ABORTED, "Closing idle sessions.",
-                             true /* idle_only */);
-}
-
-void SpdySessionPool::CloseAllSessions() {
-  while (!available_sessions_.empty()) {
-    CloseCurrentSessionsHelper(ERR_ABORTED, "Closing all sessions.",
-                               false /* idle_only */);
-  }
-}
-
-void SpdySessionPool::RegisterUnclaimedPushedStream(
-    GURL url,
-    base::WeakPtr<SpdySession> spdy_session) {
-  DCHECK(!url.is_empty());
-  // This SpdySessionPool must own |spdy_session|.
-  DCHECK(base::ContainsKey(sessions_, spdy_session.get()));
-  UnclaimedPushedStreamMap::iterator url_it =
-      unclaimed_pushed_streams_.lower_bound(url);
-  if (url_it == unclaimed_pushed_streams_.end() || url_it->first != url) {
-    WeakSessionList list;
-    list.push_back(std::move(spdy_session));
-    UnclaimedPushedStreamMap::value_type value(std::move(url), std::move(list));
-    unclaimed_pushed_streams_.insert(url_it, std::move(value));
-    return;
-  }
-  url_it->second.push_back(spdy_session);
-}
-
-void SpdySessionPool::UnregisterUnclaimedPushedStream(
-    const GURL& url,
-    SpdySession* spdy_session) {
-  DCHECK(!url.is_empty());
-  UnclaimedPushedStreamMap::iterator url_it =
-      unclaimed_pushed_streams_.find(url);
-  DCHECK(url_it != unclaimed_pushed_streams_.end());
-  size_t removed = 0;
-  for (WeakSessionList::iterator it = url_it->second.begin();
-       it != url_it->second.end();) {
-    // Lazy deletion of destroyed SpdySessions.
-    if (!*it) {
-      it = url_it->second.erase(it);
-      continue;
-    }
-    if (it->get() == spdy_session) {
-      it = url_it->second.erase(it);
-      ++removed;
-      break;
-    }
-    ++it;
-  }
-  if (url_it->second.empty()) {
-    unclaimed_pushed_streams_.erase(url_it);
-  }
-  DCHECK_EQ(1u, removed);
-}
-
-std::unique_ptr<base::Value> SpdySessionPool::SpdySessionPoolInfoToValue()
-    const {
-  std::unique_ptr<base::ListValue> list(new base::ListValue());
-
-  for (AvailableSessionMap::const_iterator it = available_sessions_.begin();
-       it != available_sessions_.end(); ++it) {
-    // Only add the session if the key in the map matches the main
-    // host_port_proxy_pair (not an alias).
-    const SpdySessionKey& key = it->first;
-    const SpdySessionKey& session_key = it->second->spdy_session_key();
-    if (key.Equals(session_key))
-      list->Append(it->second->GetInfoAsValue());
-  }
-  return std::move(list);
-}
-
-void SpdySessionPool::OnIPAddressChanged() {
-  WeakSessionList current_sessions = GetCurrentSessions();
-  for (WeakSessionList::const_iterator it = current_sessions.begin();
-       it != current_sessions.end(); ++it) {
-    if (!*it)
-      continue;
-
-// For OSs that terminate TCP connections upon relevant network changes,
-// attempt to preserve active streams by marking all sessions as going
-// away, rather than explicitly closing them. Streams may still fail due
-// to a generated TCP reset.
-#if defined(OS_ANDROID) || defined(OS_WIN) || defined(OS_IOS)
-    (*it)->MakeUnavailable();
-    (*it)->StartGoingAway(kLastStreamId, ERR_NETWORK_CHANGED);
-    (*it)->MaybeFinishGoingAway();
-#else
-    (*it)->CloseSessionOnError(ERR_NETWORK_CHANGED,
-                               "Closing current sessions.");
-    DCHECK((*it)->IsDraining());
-#endif  // defined(OS_ANDROID) || defined(OS_WIN) || defined(OS_IOS)
-    DCHECK(!IsSessionAvailable(*it));
-  }
-}
-
-void SpdySessionPool::OnSSLConfigChanged() {
-  CloseCurrentSessions(ERR_NETWORK_CHANGED);
-}
-
-void SpdySessionPool::OnCertDBChanged() {
-  CloseCurrentSessions(ERR_CERT_DATABASE_CHANGED);
-}
-
-void SpdySessionPool::DumpMemoryStats(
-    base::trace_event::ProcessMemoryDump* pmd,
-    const SpdyString& parent_dump_absolute_name) const {
-  if (sessions_.empty())
-    return;
-  size_t total_size = 0;
-  size_t buffer_size = 0;
-  size_t cert_count = 0;
-  size_t cert_size = 0;
-  size_t num_active_sessions = 0;
-  for (auto* session : sessions_) {
-    StreamSocket::SocketMemoryStats stats;
-    bool is_session_active = false;
-    total_size += session->DumpMemoryStats(&stats, &is_session_active);
-    buffer_size += stats.buffer_size;
-    cert_count += stats.cert_count;
-    cert_size += stats.cert_size;
-    if (is_session_active)
-      num_active_sessions++;
-  }
-  total_size += SpdyEstimateMemoryUsage(ObtainHpackHuffmanTable()) +
-                SpdyEstimateMemoryUsage(ObtainHpackStaticTable());
-  base::trace_event::MemoryAllocatorDump* dump =
-      pmd->CreateAllocatorDump(SpdyStringPrintf(
-          "%s/spdy_session_pool", parent_dump_absolute_name.c_str()));
-  dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
-                  base::trace_event::MemoryAllocatorDump::kUnitsBytes,
-                  total_size);
-  dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameObjectCount,
-                  base::trace_event::MemoryAllocatorDump::kUnitsObjects,
-                  sessions_.size());
-  dump->AddScalar("active_session_count",
-                  base::trace_event::MemoryAllocatorDump::kUnitsObjects,
-                  num_active_sessions);
-  dump->AddScalar("buffer_size",
-                  base::trace_event::MemoryAllocatorDump::kUnitsBytes,
-                  buffer_size);
-  dump->AddScalar("cert_count",
-                  base::trace_event::MemoryAllocatorDump::kUnitsObjects,
-                  cert_count);
-  dump->AddScalar("cert_size",
-                  base::trace_event::MemoryAllocatorDump::kUnitsBytes,
-                  cert_size);
-}
-
-bool SpdySessionPool::IsSessionAvailable(
-    const base::WeakPtr<SpdySession>& session) const {
-  for (AvailableSessionMap::const_iterator it = available_sessions_.begin();
-       it != available_sessions_.end(); ++it) {
-    if (it->second.get() == session.get())
-      return true;
-  }
-  return false;
-}
-
-void SpdySessionPool::MapKeyToAvailableSession(
-    const SpdySessionKey& key,
-    const base::WeakPtr<SpdySession>& session) {
-  DCHECK(base::ContainsKey(sessions_, session.get()));
-  std::pair<AvailableSessionMap::iterator, bool> result =
-      available_sessions_.insert(std::make_pair(key, session));
-  CHECK(result.second);
-}
-
-SpdySessionPool::AvailableSessionMap::iterator
-SpdySessionPool::LookupAvailableSessionByKey(
-    const SpdySessionKey& key) {
-  return available_sessions_.find(key);
-}
-
-void SpdySessionPool::UnmapKey(const SpdySessionKey& key) {
-  AvailableSessionMap::iterator it = LookupAvailableSessionByKey(key);
-  CHECK(it != available_sessions_.end());
-  available_sessions_.erase(it);
-}
-
-void SpdySessionPool::RemoveAliases(const SpdySessionKey& key) {
-  // Walk the aliases map, find references to this pair.
-  // TODO(mbelshe):  Figure out if this is too expensive.
-  for (AliasMap::iterator it = aliases_.begin(); it != aliases_.end(); ) {
-    if (it->second.Equals(key)) {
-      AliasMap::iterator old_it = it;
-      ++it;
-      aliases_.erase(old_it);
-    } else {
-      ++it;
-    }
-  }
-}
-
-SpdySessionPool::WeakSessionList SpdySessionPool::GetCurrentSessions() const {
-  WeakSessionList current_sessions;
-  for (SessionSet::const_iterator it = sessions_.begin();
-       it != sessions_.end(); ++it) {
-    current_sessions.push_back((*it)->GetWeakPtr());
-  }
-  return current_sessions;
-}
-
-void SpdySessionPool::CloseCurrentSessionsHelper(Error error,
-                                                 const SpdyString& description,
-                                                 bool idle_only) {
-  WeakSessionList current_sessions = GetCurrentSessions();
-  for (WeakSessionList::const_iterator it = current_sessions.begin();
-       it != current_sessions.end(); ++it) {
-    if (!*it)
-      continue;
-
-    if (idle_only && (*it)->is_active())
-      continue;
-
-    (*it)->CloseSessionOnError(error, description);
-    DCHECK(!IsSessionAvailable(*it));
-  }
-}
-
-}  // namespace net