Roll Chrome into Mojo.

net/http/http_server_properties_impl.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/http/http_server_properties_impl.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 
 namespace net {
 
 namespace {
 
 const uint64 kBrokenAlternateProtocolDelaySecs = 300;
 
 }  // namespace
 
 HttpServerPropertiesImpl::HttpServerPropertiesImpl()
     : spdy_servers_map_(SpdyServerHostPortMap::NO_AUTO_EVICT),
       alternate_protocol_map_(AlternateProtocolMap::NO_AUTO_EVICT),
       spdy_settings_map_(SpdySettingsMap::NO_AUTO_EVICT),
+      server_network_stats_map_(ServerNetworkStatsMap::NO_AUTO_EVICT),
       alternate_protocol_probability_threshold_(1),
       weak_ptr_factory_(this) {
   canonical_suffixes_.push_back(".c.youtube.com");
   canonical_suffixes_.push_back(".googlevideo.com");
   canonical_suffixes_.push_back(".googleusercontent.com");
 }
 
 HttpServerPropertiesImpl::~HttpServerPropertiesImpl() {
 }
 
@@ skipping 65 matching lines @@
 
 void HttpServerPropertiesImpl::InitializeSupportsQuic(
     SupportsQuicMap* supports_quic_map) {
   for (SupportsQuicMap::reverse_iterator it = supports_quic_map->rbegin();
        it != supports_quic_map->rend();
        ++it) {
     supports_quic_map_.insert(std::make_pair(it->first, it->second));
   }
 }
 
+void HttpServerPropertiesImpl::InitializeServerNetworkStats(
+    ServerNetworkStatsMap* server_network_stats_map) {
+  for (ServerNetworkStatsMap::reverse_iterator it =
+           server_network_stats_map->rbegin();
+       it != server_network_stats_map->rend(); ++it) {
+    server_network_stats_map_.Put(it->first, it->second);
+  }
+}
+
 void HttpServerPropertiesImpl::GetSpdyServerList(
     base::ListValue* spdy_server_list,
     size_t max_size) const {
   DCHECK(CalledOnValidThread());
   DCHECK(spdy_server_list);
   spdy_server_list->Clear();
   size_t count = 0;
   // Get the list of servers (host/port) that support SPDY.
   for (SpdyServerHostPortMap::const_iterator it = spdy_servers_map_.begin();
        it != spdy_servers_map_.end() && count < max_size; ++it) {
@@ skipping 26 matching lines @@
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 void HttpServerPropertiesImpl::Clear() {
   DCHECK(CalledOnValidThread());
   spdy_servers_map_.Clear();
   alternate_protocol_map_.Clear();
   canonical_host_to_origin_map_.clear();
   spdy_settings_map_.Clear();
   supports_quic_map_.clear();
+  server_network_stats_map_.Clear();
 }
 
 bool HttpServerPropertiesImpl::SupportsSpdy(
-    const net::HostPortPair& host_port_pair) {
+    const HostPortPair& host_port_pair) {
   DCHECK(CalledOnValidThread());
   if (host_port_pair.host().empty())
     return false;
 
   SpdyServerHostPortMap::iterator spdy_host_port =
       spdy_servers_map_.Get(host_port_pair.ToString());
   if (spdy_host_port != spdy_servers_map_.end())
     return spdy_host_port->second;
   return false;
 }
 
 void HttpServerPropertiesImpl::SetSupportsSpdy(
-    const net::HostPortPair& host_port_pair,
+    const HostPortPair& host_port_pair,
     bool support_spdy) {
   DCHECK(CalledOnValidThread());
   if (host_port_pair.host().empty())
     return;
 
   SpdyServerHostPortMap::iterator spdy_host_port =
       spdy_servers_map_.Get(host_port_pair.ToString());
   if ((spdy_host_port != spdy_servers_map_.end()) &&
       (spdy_host_port->second == support_spdy)) {
     return;
@@ skipping 220 matching lines @@
 }
 
 void HttpServerPropertiesImpl::SetSupportsQuic(
     const HostPortPair& host_port_pair,
     bool used_quic,
     const std::string& address) {
   SupportsQuic supports_quic(used_quic, address);
   supports_quic_map_.insert(std::make_pair(host_port_pair, supports_quic));
 }
 
-const SupportsQuicMap&
-HttpServerPropertiesImpl::supports_quic_map() const {
+const SupportsQuicMap& HttpServerPropertiesImpl::supports_quic_map() const {
   return supports_quic_map_;
 }
 
 void HttpServerPropertiesImpl::SetServerNetworkStats(
     const HostPortPair& host_port_pair,
-    NetworkStats stats) {
-  server_network_stats_map_[host_port_pair] = stats;
+    ServerNetworkStats stats) {
+  server_network_stats_map_.Put(host_port_pair, stats);
 }
 
-const HttpServerProperties::NetworkStats*
-HttpServerPropertiesImpl::GetServerNetworkStats(
-    const HostPortPair& host_port_pair) const {
-  ServerNetworkStatsMap::const_iterator it =
-      server_network_stats_map_.find(host_port_pair);
+const ServerNetworkStats* HttpServerPropertiesImpl::GetServerNetworkStats(
+    const HostPortPair& host_port_pair) {
+  ServerNetworkStatsMap::iterator it =
+      server_network_stats_map_.Get(host_port_pair);
   if (it == server_network_stats_map_.end()) {
     return NULL;
   }
   return &it->second;
 }
 
+const ServerNetworkStatsMap&
+HttpServerPropertiesImpl::server_network_stats_map() const {
+  return server_network_stats_map_;
+}
+
 void HttpServerPropertiesImpl::SetAlternateProtocolProbabilityThreshold(
     double threshold) {
   alternate_protocol_probability_threshold_ = threshold;
 }
 
 HttpServerPropertiesImpl::CanonicalHostMap::const_iterator
 HttpServerPropertiesImpl::GetCanonicalHost(HostPortPair server) const {
   for (size_t i = 0; i < canonical_suffixes_.size(); ++i) {
     std::string canonical_suffix = canonical_suffixes_[i];
     if (EndsWith(server.host(), canonical_suffixes_[i], false)) {
@@ skipping 42 matching lines @@
   base::TimeDelta delay = when > now ? when - now : base::TimeDelta();
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(
           &HttpServerPropertiesImpl::ExpireBrokenAlternateProtocolMappings,
           weak_ptr_factory_.GetWeakPtr()),
       delay);
 }
 
 }  // namespace net