Fix typo.

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),
       alternate_protocol_probability_threshold_(1),
       weak_ptr_factory_(this) {
-  canoncial_suffixes_.push_back(".c.youtube.com");
-  canoncial_suffixes_.push_back(".googlevideo.com");
-  canoncial_suffixes_.push_back(".googleusercontent.com");
+  canonical_suffixes_.push_back(".c.youtube.com");
+  canonical_suffixes_.push_back(".googlevideo.com");
+  canonical_suffixes_.push_back(".googleusercontent.com");
 }
 
 HttpServerPropertiesImpl::~HttpServerPropertiesImpl() {
 }
 
 void HttpServerPropertiesImpl::InitializeSpdyServers(
     std::vector<std::string>* spdy_servers,
     bool support_spdy) {
   DCHECK(CalledOnValidThread());
   if (!spdy_servers)
@@ skipping 20 matching lines @@
 
   // Add the entries from persisted data.
   for (AlternateProtocolMap::reverse_iterator it =
            alternate_protocol_map->rbegin();
        it != alternate_protocol_map->rend(); ++it) {
     alternate_protocol_map_.Put(it->first, it->second);
   }
 
   // Attempt to find canonical servers.
   int canonical_ports[] = { 80, 443 };
-  for (size_t i = 0; i < canoncial_suffixes_.size(); ++i) {
-    std::string canonical_suffix = canoncial_suffixes_[i];
+  for (size_t i = 0; i < canonical_suffixes_.size(); ++i) {
+    std::string canonical_suffix = canonical_suffixes_[i];
     for (size_t j = 0; j < arraysize(canonical_ports); ++j) {
       HostPortPair canonical_host(canonical_suffix, canonical_ports[j]);
       // If we already have a valid canonical server, we're done.
       if (ContainsKey(canonical_host_to_origin_map_, canonical_host) &&
           (alternate_protocol_map_.Peek(canonical_host_to_origin_map_[
                canonical_host]) != alternate_protocol_map_.end())) {
         continue;
       }
       // Now attempt to find a server which matches this origin and set it as
       // canonical .
       for (AlternateProtocolMap::const_iterator it =
                alternate_protocol_map_.begin();
            it != alternate_protocol_map_.end(); ++it) {
-        if (EndsWith(it->first.host(), canoncial_suffixes_[i], false)) {
+        if (EndsWith(it->first.host(), canonical_suffixes_[i], false)) {
           canonical_host_to_origin_map_[canonical_host] = it->first;
           break;
         }
       }
     }
   }
 }
 
 void HttpServerPropertiesImpl::InitializeSpdySettingsServers(
     SpdySettingsMap* spdy_settings_map) {
@@ skipping 112 matching lines @@
     return true;
   }
 
   return GetCanonicalHost(server) != canonical_host_to_origin_map_.end();
 }
 
 std::string HttpServerPropertiesImpl::GetCanonicalSuffix(
     const HostPortPair& server) {
   // If this host ends with a canonical suffix, then return the canonical
   // suffix.
-  for (size_t i = 0; i < canoncial_suffixes_.size(); ++i) {
-    std::string canonical_suffix = canoncial_suffixes_[i];
-    if (EndsWith(server.host(), canoncial_suffixes_[i], false)) {
+  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)) {
       return canonical_suffix;
     }
   }
   return std::string();
 }
 
 AlternateProtocolInfo
 HttpServerPropertiesImpl::GetAlternateProtocol(
     const HostPortPair& server) {
   DCHECK(HasAlternateProtocol(server));
@@ skipping 53 matching lines @@
       // before the first completes. In this case, only one of the jobs
       // would reach this code, whereas all of them should should have.
       HistogramAlternateProtocolUsage(ALTERNATE_PROTOCOL_USAGE_MAPPING_MISSING);
     }
   }
 
   alternate_protocol_map_.Put(server, alternate);
 
   // If this host ends with a canonical suffix, then set it as the
   // canonical host.
-  for (size_t i = 0; i < canoncial_suffixes_.size(); ++i) {
-    std::string canonical_suffix = canoncial_suffixes_[i];
-    if (EndsWith(server.host(), canoncial_suffixes_[i], false)) {
+  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)) {
       HostPortPair canonical_host(canonical_suffix, server.port());
       canonical_host_to_origin_map_[canonical_host] = server;
       break;
     }
   }
 }
 
 void HttpServerPropertiesImpl::SetBrokenAlternateProtocol(
     const HostPortPair& server) {
   AlternateProtocolMap::iterator it = alternate_protocol_map_.Get(server);
@@ skipping 136 matching lines @@
   return &it->second;
 }
 
 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 < canoncial_suffixes_.size(); ++i) {
-    std::string canonical_suffix = canoncial_suffixes_[i];
-    if (EndsWith(server.host(), canoncial_suffixes_[i], false)) {
+  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)) {
       HostPortPair canonical_host(canonical_suffix, server.port());
       return canonical_host_to_origin_map_.find(canonical_host);
     }
   }
 
   return canonical_host_to_origin_map_.end();
 }
 
 void HttpServerPropertiesImpl::RemoveCanonicalHost(
     const HostPortPair& server) {
@@ skipping 32 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