Refactor: Address some style comments from a review (which missed the original check-in).

Review URL: http://codereview.chromium.org/322009

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@29874 0039d316-1c4b-4281-b951-d872f2087c98

9 files changed, 40 insertions, 24 deletions

diff --git a/net/base/address_family.h b/net/base/address_family.h
index faa9193..065927f 100644
--- a/net/base/address_family.h
+++ b/net/base/address_family.h
@@ -8,10 +8,11 @@
 namespace net {
 
 // Enum wrapper around the address family types supported by host resolver
-// procedures. These correspond with AF_UNSPEC and AF_INET.
+// procedures.
 enum AddressFamily {
-  ADDRESS_FAMILY_UNSPECIFIED,
-  ADDRESS_FAMILY_IPV4_ONLY,
+  ADDRESS_FAMILY_UNSPECIFIED,   // AF_UNSPEC
+  ADDRESS_FAMILY_IPV4,          // AF_INET
+  ADDRESS_FAMILY_IPV6,          // AF_INET6
 };
 
 }  // namesapce net
diff --git a/net/base/host_cache_unittest.cc b/net/base/host_cache_unittest.cc
index 55742ba..c5a0f21 100644
--- a/net/base/host_cache_unittest.cc
+++ b/net/base/host_cache_unittest.cc
@@ -214,7 +214,7 @@ TEST(HostCacheTest, AddressFamilyIsPartOfKey) {
   base::TimeTicks now;
 
   HostCache::Key key1("foobar.com", ADDRESS_FAMILY_UNSPECIFIED);
-  HostCache::Key key2("foobar.com", ADDRESS_FAMILY_IPV4_ONLY);
+  HostCache::Key key2("foobar.com", ADDRESS_FAMILY_IPV4);
 
   const HostCache::Entry* entry1 = NULL;  // Entry for key1
   const HostCache::Entry* entry2 = NULL;  // Entry for key2
diff --git a/net/base/host_resolver_impl.cc b/net/base/host_resolver_impl.cc
index e3cfcd3..6b5a20f 100644
--- a/net/base/host_resolver_impl.cc
+++ b/net/base/host_resolver_impl.cc
@@ -331,7 +331,7 @@ int HostResolverImpl::Resolve(const RequestInfo& info,
   // outstanding jobs map.
   Key key(info.hostname(), info.address_family());
   if (disable_ipv6_)
-    key.address_family = ADDRESS_FAMILY_IPV4_ONLY;
+    key.address_family = ADDRESS_FAMILY_IPV4;
 
   // If we have an unexpired cache entry, use it.
   if (info.allow_cached_response()) {
diff --git a/net/base/host_resolver_proc.cc b/net/base/host_resolver_proc.cc
index af92087..cd6fc12 100644
--- a/net/base/host_resolver_proc.cc
+++ b/net/base/host_resolver_proc.cc
@@ -138,10 +138,17 @@ int SystemHostResolverProc(const std::string& host,
   struct addrinfo hints = {0};
 
   switch (address_family) {
-    case ADDRESS_FAMILY_IPV4_ONLY:
+    case ADDRESS_FAMILY_IPV4:
       hints.ai_family = AF_INET;
       break;
+    case ADDRESS_FAMILY_IPV6:
+      hints.ai_family = AF_INET6;
+      break;
+    case ADDRESS_FAMILY_UNSPECIFIED:
+      hints.ai_family = AF_UNSPEC;
+      break;
     default:
+      NOTREACHED();
       hints.ai_family = AF_UNSPEC;
   }
 
diff --git a/net/base/mock_host_resolver.cc b/net/base/mock_host_resolver.cc
index 4a723a6..46772b3 100644
--- a/net/base/mock_host_resolver.cc
+++ b/net/base/mock_host_resolver.cc
@@ -135,10 +135,11 @@ RuleBasedHostResolverProc::~RuleBasedHostResolverProc() {
 
 void RuleBasedHostResolverProc::AddRule(const std::string& host_pattern,
                                         const std::string& replacement) {
-  AddRuleForFamily(host_pattern, ADDRESS_FAMILY_UNSPECIFIED, replacement);
+  AddRuleForAddressFamily(host_pattern, ADDRESS_FAMILY_UNSPECIFIED,
+                          replacement);
 }
 
-void RuleBasedHostResolverProc::AddRuleForFamily(
+void RuleBasedHostResolverProc::AddRuleForAddressFamily(
     const std::string& host_pattern,
     AddressFamily address_family,
     const std::string& replacement) {
@@ -148,7 +149,6 @@ void RuleBasedHostResolverProc::AddRuleForFamily(
   rules_.push_back(rule);
 }
 
-
 void RuleBasedHostResolverProc::AddIPv6Rule(const std::string& host_pattern,
                                             const std::string& ipv6_literal) {
   Rule rule(Rule::kResolverTypeIPV6Literal, host_pattern,
diff --git a/net/base/mock_host_resolver.h b/net/base/mock_host_resolver.h
index 96788cc..eee005c 100644
--- a/net/base/mock_host_resolver.h
+++ b/net/base/mock_host_resolver.h
@@ -103,9 +103,9 @@ class RuleBasedHostResolverProc : public HostResolverProc {
                const std::string& replacement);
 
   // Same as AddRule(), but further restricts to |address_family|.
-  void AddRuleForFamily(const std::string& host_pattern,
-                        AddressFamily address_family,
-                        const std::string& replacement);
+  void AddRuleForAddressFamily(const std::string& host_pattern,
+                               AddressFamily address_family,
+                               const std::string& replacement);
 
   // Same as AddRule(), but the replacement is expected to be an IPV6 literal.
   // You should use this in place of AddRule(), since the system's host resolver
diff --git a/net/proxy/proxy_resolver_js_bindings.cc b/net/proxy/proxy_resolver_js_bindings.cc
index cbeba08..f9ea5ae 100644
--- a/net/proxy/proxy_resolver_js_bindings.cc
+++ b/net/proxy/proxy_resolver_js_bindings.cc
@@ -110,10 +110,13 @@ class DefaultJSBindings : public ProxyResolverJSBindings {
       return std::string();
 
     // Do a sync resolve of the hostname.
-    // Disable IPv6 results, see http://crbug.com/24641 for motivation.
+    // Disable IPv6 results. We do this because Internet Explorer does it --
+    // consequently a lot of existing PAC scripts assume they will only get
+    // IPv4 results, and will misbehave if they get an IPv6 result.
+    // See http://crbug.com/24641 for more details.
     net::AddressList address_list;
     int result = host_resolver_->Resolve(host,
-                                         ADDRESS_FAMILY_IPV4_ONLY,
+                                         ADDRESS_FAMILY_IPV4,
                                          &address_list);
 
     if (result != OK)
diff --git a/net/proxy/proxy_resolver_js_bindings_unittest.cc b/net/proxy/proxy_resolver_js_bindings_unittest.cc
index 4a8c5d2..b84c829 100644
--- a/net/proxy/proxy_resolver_js_bindings_unittest.cc
+++ b/net/proxy/proxy_resolver_js_bindings_unittest.cc
@@ -49,7 +49,7 @@ TEST(ProxyResolverJSBindingsTest, MyIpAddress) {
 }
 
 // Tests that myIpAddress() and dnsResolve() pass the flag
-// ADDRESS_FAMILY_IPV4_ONLY to the host resolver, as we don't want them
+// ADDRESS_FAMILY_IPV4 to the host resolver, as we don't want them
 // to return IPv6 results.
 TEST(ProxyResolverJSBindingsTest, DontUseIPv6) {
   scoped_refptr<MockHostResolver> host_resolver(new MockHostResolver);
@@ -62,11 +62,11 @@ TEST(ProxyResolverJSBindingsTest, DontUseIPv6) {
   // Make it so requests resolve to particular address patterns based on family:
   //  IPV4_ONLY --> 192.168.1.*
   //  UNSPECIFIED --> 192.168.2.1
-  host_resolver->rules()->AddRuleForFamily(
-      "foo", ADDRESS_FAMILY_IPV4_ONLY, "192.168.1.1");
-  host_resolver->rules()->AddRuleForFamily(
-      "*", ADDRESS_FAMILY_IPV4_ONLY, "192.168.1.2");
-  host_resolver->rules()->AddRuleForFamily(
+  host_resolver->rules()->AddRuleForAddressFamily(
+      "foo", ADDRESS_FAMILY_IPV4, "192.168.1.1");
+  host_resolver->rules()->AddRuleForAddressFamily(
+      "*", ADDRESS_FAMILY_IPV4, "192.168.1.2");
+  host_resolver->rules()->AddRuleForAddressFamily(
       "*", ADDRESS_FAMILY_UNSPECIFIED, "192.168.2.1");
 
   // Verify that our mock setups works as expected, and we get different results
@@ -76,7 +76,7 @@ TEST(ProxyResolverJSBindingsTest, DontUseIPv6) {
   EXPECT_EQ(OK, host_resolver->Resolve(info, &address_list, NULL, NULL, NULL));
   EXPECT_EQ("192.168.2.1", NetAddressToString(address_list.head()));
 
-  info.set_address_family(ADDRESS_FAMILY_IPV4_ONLY);
+  info.set_address_family(ADDRESS_FAMILY_IPV4);
   EXPECT_EQ(OK, host_resolver->Resolve(info, &address_list, NULL, NULL, NULL));
   EXPECT_EQ("192.168.1.1", NetAddressToString(address_list.head()));
 
diff --git a/net/url_request/url_request_view_net_internals_job.cc b/net/url_request/url_request_view_net_internals_job.cc
index 92fcc14..ad97b63 100644
--- a/net/url_request/url_request_view_net_internals_job.cc
+++ b/net/url_request/url_request_view_net_internals_job.cc
@@ -288,10 +288,15 @@ class HostResolverCacheSubSection : public SubSection {
 
   static std::string AddressFamilyToString(net::AddressFamily address_family) {
     switch (address_family) {
-      case net::ADDRESS_FAMILY_IPV4_ONLY:
-        return "IPV4_ONLY";
-      default:
+      case net::ADDRESS_FAMILY_IPV4:
+        return "IPV4";
+      case net::ADDRESS_FAMILY_IPV6:
+        return "IPV6";
+      case net::ADDRESS_FAMILY_UNSPECIFIED:
         return "UNSPECIFIED";
+      default:
+        NOTREACHED();
+        return "???";
     }
   }
 };