Fix some instances of -Wshadow.

Bug: 794619
Change-Id: I499cd08727afa717002a6f7fd3658a7d45675c96
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3100952
Commit-Queue: Peter Kasting <pkasting@chromium.org>
Reviewed-by: Ryan Sleevi <rsleevi@chromium.org>
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Cr-Commit-Position: refs/heads/master@{#912813}

components/cronet/stale_host_resolver_unittest.cc

@@ -96,11 +96,11 @@ std::unique_ptr<net::MockDnsClient> CreateHangingMockDnsClient() {
   net::MockDnsClientRuleList rules;
   rules.emplace_back(
       kHostname, net::dns_protocol::kTypeA, false /* secure */,
-      net::MockDnsClientRule::Result(net::MockDnsClientRule::FAIL),
+      net::MockDnsClientRule::Result(net::MockDnsClientRule::ResultType::kFail),
       true /* delay */);
   rules.emplace_back(
       kHostname, net::dns_protocol::kTypeAAAA, false /* secure */,
-      net::MockDnsClientRule::Result(net::MockDnsClientRule::FAIL),
+      net::MockDnsClientRule::Result(net::MockDnsClientRule::ResultType::kFail),
       true /* delay */);
 
   return std::make_unique<net::MockDnsClient>(config, std::move(rules));

net/android/network_change_notifier_android.cc

@@ -178,24 +178,24 @@ void NetworkChangeNotifierAndroid::OnMaxBandwidthChanged(
 
 void NetworkChangeNotifierAndroid::OnNetworkConnected(NetworkHandle network) {
   NetworkChangeNotifier::NotifyObserversOfSpecificNetworkChange(
-      NetworkChangeType::CONNECTED, network);
+      NetworkChangeType::kConnected, network);
 }
 
 void NetworkChangeNotifierAndroid::OnNetworkSoonToDisconnect(
     NetworkHandle network) {
   NetworkChangeNotifier::NotifyObserversOfSpecificNetworkChange(
-      NetworkChangeType::SOON_TO_DISCONNECT, network);
+      NetworkChangeType::kSoonToDisconnect, network);
 }
 
 void NetworkChangeNotifierAndroid::OnNetworkDisconnected(
     NetworkHandle network) {
   NetworkChangeNotifier::NotifyObserversOfSpecificNetworkChange(
-      NetworkChangeType::DISCONNECTED, network);
+      NetworkChangeType::kDisconnected, network);
 }
 
 void NetworkChangeNotifierAndroid::OnNetworkMadeDefault(NetworkHandle network) {
   NetworkChangeNotifier::NotifyObserversOfSpecificNetworkChange(
-      NetworkChangeType::MADE_DEFAULT, network);
+      NetworkChangeType::kMadeDefault, network);
 }
 
 NetworkChangeNotifierAndroid::NetworkChangeNotifierAndroid(

net/base/host_mapping_rules.cc

@@ -44,29 +44,30 @@ HostMappingRules& HostMappingRules::operator=(
 
 bool HostMappingRules::RewriteHost(HostPortPair* host_port) const {
   // Check if the hostname was remapped.
-  for (const auto& rule : map_rules_) {
+  for (const auto& map_rule : map_rules_) {
     // The rule's hostname_pattern will be something like:
     //     www.foo.com
     //     *.foo.com
     //     www.foo.com:1234
     //     *.foo.com:1234
     // First, we'll check for a match just on hostname.
     // If that fails, we'll check for a match with both hostname and port.
-    if (!base::MatchPattern(host_port->host(), rule.hostname_pattern)) {
+    if (!base::MatchPattern(host_port->host(), map_rule.hostname_pattern)) {
       std::string host_port_string = host_port->ToString();
-      if (!base::MatchPattern(host_port_string, rule.hostname_pattern))
+      if (!base::MatchPattern(host_port_string, map_rule.hostname_pattern))
         continue;  // This rule doesn't apply.
     }
 
     // Check if the hostname was excluded.
-    for (const auto& rule : exclusion_rules_) {
-      if (base::MatchPattern(host_port->host(), rule.hostname_pattern))
+    for (const auto& exclusion_rule : exclusion_rules_) {
+      if (base::MatchPattern(host_port->host(),
+                             exclusion_rule.hostname_pattern))
         return false;
     }
 
-    host_port->set_host(rule.replacement_hostname);
-    if (rule.replacement_port != -1)
-      host_port->set_port(static_cast<uint16_t>(rule.replacement_port));
+    host_port->set_host(map_rule.replacement_hostname);
+    if (map_rule.replacement_port != -1)
+      host_port->set_port(static_cast<uint16_t>(map_rule.replacement_port));
     return true;
   }
 

net/base/ip_address_unittest.cc

@@ -213,9 +213,8 @@ TEST(IPAddressTest, IsPubliclyRoutableIPv4) {
                {"224.0.0.0", RESERVED},
                {"255.255.255.255", RESERVED}};
 
-  IPAddress address;
-  IPAddress mapped_address;
   for (const auto& test : tests) {
+    IPAddress address;
     EXPECT_TRUE(address.AssignFromIPLiteral(test.address));
     ASSERT_TRUE(address.IsValid());
     EXPECT_EQ(!test.is_reserved, address.IsPubliclyRoutable());

net/base/ip_endpoint_unittest.cc

@@ -84,8 +84,10 @@ class IPEndPointTest : public PlatformTest {
 };
 
 TEST_F(IPEndPointTest, Constructor) {
-  IPEndPoint endpoint;
-  EXPECT_EQ(0, endpoint.port());
+  {
+    IPEndPoint endpoint;
+    EXPECT_EQ(0, endpoint.port());
+  }
 
   for (const auto& test : tests) {
     IPEndPoint endpoint(test.ip_address, 80);
@@ -353,8 +355,10 @@ TEST_F(IPEndPointTest, LessThan) {
 }
 
 TEST_F(IPEndPointTest, ToString) {
-  IPEndPoint endpoint;
-  EXPECT_EQ(0, endpoint.port());
+  {
+    IPEndPoint endpoint;
+    EXPECT_EQ(0, endpoint.port());
+  }
 
   uint16_t port = 100;
   for (const auto& test : tests) {

net/base/mock_network_change_notifier.cc

@@ -61,7 +61,7 @@ void MockNetworkChangeNotifier::NotifyNetworkMadeDefault(
 void MockNetworkChangeNotifier::QueueNetworkMadeDefault(
     NetworkChangeNotifier::NetworkHandle network) {
   NetworkChangeNotifier::NotifyObserversOfSpecificNetworkChange(
-      NetworkChangeNotifier::MADE_DEFAULT, network);
+      NetworkChangeNotifier::NetworkChangeType::kMadeDefault, network);
 }
 
 void MockNetworkChangeNotifier::NotifyNetworkDisconnected(
@@ -74,13 +74,13 @@ void MockNetworkChangeNotifier::NotifyNetworkDisconnected(
 void MockNetworkChangeNotifier::QueueNetworkDisconnected(
     NetworkChangeNotifier::NetworkHandle network) {
   NetworkChangeNotifier::NotifyObserversOfSpecificNetworkChange(
-      NetworkChangeNotifier::DISCONNECTED, network);
+      NetworkChangeNotifier::NetworkChangeType::kDisconnected, network);
 }
 
 void MockNetworkChangeNotifier::NotifyNetworkConnected(
     NetworkChangeNotifier::NetworkHandle network) {
   NetworkChangeNotifier::NotifyObserversOfSpecificNetworkChange(
-      NetworkChangeNotifier::CONNECTED, network);
+      NetworkChangeNotifier::NetworkChangeType::kConnected, network);
   // Spin the message loop so the notification is delivered.
   base::RunLoop().RunUntilIdle();
 }

net/base/network_change_notifier.cc

@@ -942,19 +942,19 @@ void NetworkChangeNotifier::NotifyObserversOfSpecificNetworkChangeImpl(
     NetworkChangeType type,
     NetworkHandle network) {
   switch (type) {
-    case CONNECTED:
+    case NetworkChangeType::kConnected:
       network_observer_list_->Notify(
           FROM_HERE, &NetworkObserver::OnNetworkConnected, network);
       break;
-    case DISCONNECTED:
+    case NetworkChangeType::kDisconnected:
       network_observer_list_->Notify(
           FROM_HERE, &NetworkObserver::OnNetworkDisconnected, network);
       break;
-    case SOON_TO_DISCONNECT:
+    case NetworkChangeType::kSoonToDisconnect:
       network_observer_list_->Notify(
           FROM_HERE, &NetworkObserver::OnNetworkSoonToDisconnect, network);
       break;
-    case MADE_DEFAULT:
+    case NetworkChangeType::kMadeDefault:
       network_observer_list_->Notify(
           FROM_HERE, &NetworkObserver::OnNetworkMadeDefault, network);
       break;

net/base/network_change_notifier.h

@@ -530,11 +530,11 @@ class NET_EXPORT NetworkChangeNotifier {
  protected:
   // Types of network changes specified to
   // NotifyObserversOfSpecificNetworkChange.
-  enum NetworkChangeType {
-    CONNECTED,
-    DISCONNECTED,
-    SOON_TO_DISCONNECT,
-    MADE_DEFAULT
+  enum class NetworkChangeType {
+    kConnected,
+    kDisconnected,
+    kSoonToDisconnect,
+    kMadeDefault
   };
 
   // NetworkChanged signal is calculated from the IPAddressChanged and

net/base/network_interfaces_win.h

@@ -46,7 +46,6 @@ struct NET_EXPORT WlanApi {
     return ERROR_SUCCESS;
   }
 
-  HMODULE module;
   WlanOpenHandleFunc open_handle_func;
   WlanEnumInterfacesFunc enum_interfaces_func;
   WlanQueryInterfaceFunc query_interface_func;

net/cert/cert_verify_proc.cc

@@ -452,10 +452,10 @@ base::Value CertVerifyParams(X509Certificate* cert,
 
   if (!additional_trust_anchors.empty()) {
     base::Value certs(base::Value::Type::LIST);
-    for (auto& cert : additional_trust_anchors) {
+    for (auto& anchor : additional_trust_anchors) {
       std::string pem_encoded;
       if (X509Certificate::GetPEMEncodedFromDER(
-              x509_util::CryptoBufferAsStringPiece(cert->cert_buffer()),
+              x509_util::CryptoBufferAsStringPiece(anchor->cert_buffer()),
               &pem_encoded)) {
         certs.Append(std::move(pem_encoded));
       }

net/cookies/cookie_monster_unittest.cc

@@ -3502,7 +3502,7 @@ TEST_F(CookieMonsterTest, LeaveSecureCookiesAlone_DomainMatch) {
   const char* kDomain = "b.a.foo.com";
   const char* kSubdomain = "c.b.a.foo.com";
   // This domain does not match any, aside from the registrable domain.
-  const char* kOtherDomain = "z.foo.com";
+  const char* kAnotherDomain = "z.foo.com";
 
   for (const char* preexisting_cookie_host :
        {kRegistrableDomain, kSuperdomain, kDomain, kSubdomain}) {
@@ -3591,7 +3591,7 @@ TEST_F(CookieMonsterTest, LeaveSecureCookiesAlone_DomainMatch) {
   // Test non-domain-matching case. These sets should all be allowed because the
   // cookie is not equivalent.
   GURL nonmatching_https_url(base::StrCat(
-      {url::kHttpsScheme, url::kStandardSchemeSeparator, kOtherDomain}));
+      {url::kHttpsScheme, url::kStandardSchemeSeparator, kAnotherDomain}));
 
   for (const char* host : {kSuperdomain, kDomain, kSubdomain}) {
     GURL https_url(
@@ -3605,7 +3605,7 @@ TEST_F(CookieMonsterTest, LeaveSecureCookiesAlone_DomainMatch) {
                     .IsInclude());
     EXPECT_TRUE(CreateAndSetCookieReturnStatus(
                     cm.get(), nonmatching_https_url,
-                    base::StrCat({"B=0; Secure; Domain=", kOtherDomain}))
+                    base::StrCat({"B=0; Secure; Domain=", kAnotherDomain}))
                     .IsInclude());
 
     // New cookie from insecure URL is set.

net/disk_cache/blockfile/rankings.cc

@@ -838,8 +838,7 @@ int Rankings::CheckListSection(List list, Addr end1, Addr end2, bool forward,
     (*num_items)++;
 
     if (next_addr == prev_addr) {
-      Addr last = forward ? tails_[list] : heads_[list];
-      if (next_addr == last)
+      if (next_addr == (forward ? tails_[list] : heads_[list]))
         return ERR_NO_ERROR;
       return ERR_INVALID_TAIL;
     }

net/disk_cache/entry_unittest.cc

@@ -1603,7 +1603,7 @@ TEST_F(DiskCacheEntryTest, MemoryOnlyEnumerationWithSparseEntries) {
     ++count;
     disk_cache::MemEntryImpl* mem_entry =
         reinterpret_cast<disk_cache::MemEntryImpl*>(entry);
-    EXPECT_EQ(disk_cache::MemEntryImpl::PARENT_ENTRY, mem_entry->type());
+    EXPECT_EQ(disk_cache::MemEntryImpl::EntryType::kParent, mem_entry->type());
     mem_entry->Close();
   }
   EXPECT_EQ(1, count);

net/disk_cache/memory/mem_backend_impl.cc

@@ -125,7 +125,7 @@ void MemBackendImpl::OnEntryUpdated(MemEntryImpl* entry) {
 }
 
 void MemBackendImpl::OnEntryDoomed(MemEntryImpl* entry) {
-  if (entry->type() == MemEntryImpl::PARENT_ENTRY)
+  if (entry->type() == MemEntryImpl::EntryType::kParent)
     entries_.erase(entry->key());
   // LinkedList<>::RemoveFromList() removes |entry| from |lru_list_|.
   entry->RemoveFromList();

net/disk_cache/memory/mem_entry_impl.cc

@@ -61,10 +61,10 @@ base::Value NetLogEntryCreationParams(const MemEntryImpl* entry) {
   base::Value dict(base::Value::Type::DICTIONARY);
   std::string key;
   switch (entry->type()) {
-    case MemEntryImpl::PARENT_ENTRY:
+    case MemEntryImpl::EntryType::kParent:
       key = entry->key();
       break;
-    case MemEntryImpl::CHILD_ENTRY:
+    case MemEntryImpl::EntryType::kChild:
       key = GenerateChildName(entry->parent()->key(), entry->child_id());
       break;
   }
@@ -103,14 +103,14 @@ MemEntryImpl::MemEntryImpl(base::WeakPtr<MemBackendImpl> backend,
 
 void MemEntryImpl::Open() {
   // Only a parent entry can be opened.
-  DCHECK_EQ(PARENT_ENTRY, type());
+  DCHECK_EQ(EntryType::kParent, type());
   CHECK_NE(ref_count_, std::numeric_limits<uint32_t>::max());
   ++ref_count_;
   DCHECK(!doomed_);
 }
 
 bool MemEntryImpl::InUse() const {
-  if (type() == CHILD_ENTRY)
+  if (type() == EntryType::kChild)
     return parent_->InUse();
 
   return ref_count_ > 0;
@@ -144,7 +144,7 @@ void MemEntryImpl::Doom() {
 }
 
 void MemEntryImpl::Close() {
-  DCHECK_EQ(PARENT_ENTRY, type());
+  DCHECK_EQ(EntryType::kParent, type());
   CHECK_GT(ref_count_, 0u);
   --ref_count_;
   if (ref_count_ == 0 && !doomed_) {
@@ -164,7 +164,7 @@ void MemEntryImpl::Close() {
 
 std::string MemEntryImpl::GetKey() const {
   // A child entry doesn't have key so this method should not be called.
-  DCHECK_EQ(PARENT_ENTRY, type());
+  DCHECK_EQ(EntryType::kParent, type());
   return key_;
 }
 
@@ -269,7 +269,7 @@ RangeResult MemEntryImpl::GetAvailableRange(int64_t offset,
 }
 
 bool MemEntryImpl::CouldBeSparse() const {
-  DCHECK_EQ(PARENT_ENTRY, type());
+  DCHECK_EQ(EntryType::kParent, type());
   return (children_.get() != nullptr);
 }
 
@@ -308,7 +308,7 @@ MemEntryImpl::~MemEntryImpl() {
   if (backend_)
     backend_->ModifyStorageSize(-GetStorageSize());
 
-  if (type() == PARENT_ENTRY) {
+  if (type() == EntryType::kParent) {
     if (children_) {
       EntryMap children;
       children_->swap(children);
@@ -328,7 +328,7 @@ MemEntryImpl::~MemEntryImpl() {
 
 int MemEntryImpl::InternalReadData(int index, int offset, IOBuffer* buf,
                                    int buf_len) {
-  DCHECK(type() == PARENT_ENTRY || index == kSparseData);
+  DCHECK(type() == EntryType::kParent || index == kSparseData);
 
   if (index < 0 || index >= kNumStreams || buf_len < 0)
     return net::ERR_INVALID_ARGUMENT;
@@ -350,7 +350,7 @@ int MemEntryImpl::InternalReadData(int index, int offset, IOBuffer* buf,
 
 int MemEntryImpl::InternalWriteData(int index, int offset, IOBuffer* buf,
                                     int buf_len, bool truncate) {
-  DCHECK(type() == PARENT_ENTRY || index == kSparseData);
+  DCHECK(type() == EntryType::kParent || index == kSparseData);
   if (!backend_)
     return net::ERR_INSUFFICIENT_RESOURCES;
 
@@ -399,7 +399,7 @@ int MemEntryImpl::InternalWriteData(int index, int offset, IOBuffer* buf,
 int MemEntryImpl::InternalReadSparseData(int64_t offset,
                                          IOBuffer* buf,
                                          int buf_len) {
-  DCHECK_EQ(PARENT_ENTRY, type());
+  DCHECK_EQ(EntryType::kParent, type());
 
   if (!InitSparseInfo())
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
@@ -463,7 +463,7 @@ int MemEntryImpl::InternalReadSparseData(int64_t offset,
 int MemEntryImpl::InternalWriteSparseData(int64_t offset,
                                           IOBuffer* buf,
                                           int buf_len) {
-  DCHECK_EQ(PARENT_ENTRY, type());
+  DCHECK_EQ(EntryType::kParent, type());
 
   if (!InitSparseInfo())
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
@@ -533,7 +533,7 @@ int MemEntryImpl::InternalWriteSparseData(int64_t offset,
 }
 
 RangeResult MemEntryImpl::InternalGetAvailableRange(int64_t offset, int len) {
-  DCHECK_EQ(PARENT_ENTRY, type());
+  DCHECK_EQ(EntryType::kParent, type());
 
   if (!InitSparseInfo())
     return RangeResult(net::ERR_CACHE_OPERATION_NOT_SUPPORTED);
@@ -580,7 +580,7 @@ RangeResult MemEntryImpl::InternalGetAvailableRange(int64_t offset, int len) {
 }
 
 bool MemEntryImpl::InitSparseInfo() {
-  DCHECK_EQ(PARENT_ENTRY, type());
+  DCHECK_EQ(EntryType::kParent, type());
 
   if (!children_) {
     // If we already have some data in sparse stream but we are being
@@ -597,7 +597,7 @@ bool MemEntryImpl::InitSparseInfo() {
 }
 
 MemEntryImpl* MemEntryImpl::GetChild(int64_t offset, bool create) {
-  DCHECK_EQ(PARENT_ENTRY, type());
+  DCHECK_EQ(EntryType::kParent, type());
   int64_t index = ToChildIndex(offset);
   auto i = children_->find(index);
   if (i != children_->end())