Rework a bit the NetworkList implementation.

chrome/browser/chromeos/network_list.cc

 // Copyright (c) 2010 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 "chrome/browser/chromeos/network_list.h"
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "grit/generated_resources.h"
 
 namespace chromeos {
 
 NetworkList::NetworkList()
     : connected_network_index_(-1),
       connecting_network_index_(-1) {
 }
 
 NetworkList::NetworkItem* NetworkList::GetNetworkAt(int index) {
-  return index >= 0 && index < static_cast<int>(networks_.size()) ?
-      &networks_[index] : NULL;
+  return index >= 0 && index < size() ? &networks_[index] : NULL;
 }
 
 const NetworkList::NetworkItem* NetworkList::GetNetworkById(NetworkType type,
-                                                      const string16& id) {
+    const string16& id) {
   return GetNetworkAt(GetNetworkIndexById(type, id));
 }
 
 int NetworkList::GetNetworkIndexById(NetworkType type,
                                      const string16& id) const {
   if (NETWORK_EMPTY == type || id.empty()) return -1;
   std::string network_id = UTF16ToASCII(id);
-  for (size_t i = 0; i < networks_.size(); i++) {
+  for (int i = 0; i < size(); ++i) {
     if (type == networks_[i].network_type) {
       switch (type) {
         case NETWORK_ETHERNET:
           // Assuming that there's only single Ethernet network.
           return i;
 
         case NETWORK_WIFI:
           if (network_id == networks_[i].wifi_network.ssid)
             return i;
           break;
 
         case NETWORK_CELLULAR:
           if (network_id == networks_[i].cellular_network.name)
             return i;
           break;
 
         default:
           break;
       }
     }
   }
   return -1;
 }
 
 // Returns currently connected network if there is one.
 const NetworkList::NetworkItem* NetworkList::ConnectedNetwork() const {
-  if (connected_network_index_ >= 0 &&
-      connected_network_index_ < static_cast<int>(networks_.size())) {
+  if (connected_network_index_ >= 0 && connected_network_index_ < size())
     return &networks_[connected_network_index_];
-  } else {
-    return NULL;
-  }
+  return NULL;
 }
 
 // Returns currently connecting network if there is one.
 const NetworkList::NetworkItem* NetworkList::ConnectingNetwork() const {
-  if (connecting_network_index_ >= 0 &&
-      connecting_network_index_ < static_cast<int>(networks_.size())) {
+  if (connecting_network_index_ >= 0 && connecting_network_index_ < size())
     return &networks_[connecting_network_index_];
-  } else {
-    return NULL;
-  }
+  return NULL;
 }
 
 void NetworkList::NetworkChanged(chromeos::NetworkLibrary* network_lib) {
   connected_network_index_ = -1;
   connecting_network_index_ = -1;
   networks_.clear();
   // Index of the last added network item.
   int index = 0;
   if (!network_lib || !CrosLibrary::Get()->EnsureLoaded())
     return;
@@ skipping 38 matching lines @@
                          network_lib->cellular_connecting());
     }
   }
 }
 
 void NetworkList::SetNetworksIndices(int index,
                                      bool connected,
                                      bool connecting) {
   if (connected_network_index_  != -1 ||
       connecting_network_index_ != -1 ||
-      index < 0 || index >= static_cast<int>(networks_.size()))
+      index < 0 || index >= size()) {
     return;
+  }
 
-  if (connected) {
+  if (connected)
     connected_network_index_ = index;
-  } else if (connecting) {
+  else if (connecting)
     connecting_network_index_ = index;
-  }
 }
 
 }  // namespace chromeos