Use GUID instead of ServicePath in networkingPrivate API

chromeos/network/network_state_handler.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 "chromeos/network/network_state_handler.h"
 
 #include "base/bind.h"
 #include "base/format_macros.h"
+#include "base/guid.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chromeos/network/device_state.h"
 #include "chromeos/network/favorite_state.h"
 #include "chromeos/network/managed_state.h"
@@ skipping 168 matching lines @@
 const NetworkState* NetworkStateHandler::DefaultNetwork() const {
   if (default_network_path_.empty())
     return NULL;
   return GetNetworkState(default_network_path_);
 }
 
 const FavoriteState* NetworkStateHandler::DefaultFavoriteNetwork() const {
   const NetworkState* default_network = DefaultNetwork();
   if (!default_network)
     return NULL;
-  const FavoriteState* default_favorite =
-      GetFavoriteState(default_network->path());
-  DCHECK(default_network->type() != shill::kTypeWifi ||
-         default_favorite) << "No favorite for: " << default_network->path();
+  const FavoriteState* default_favorite = GetFavoriteStateFromServicePath(
+      default_network->path(), true /* configured_only */);
+  DCHECK(default_network->type() != shill::kTypeWifi || default_favorite)
+      << "No favorite for: " << default_network->path();
   DCHECK(!default_favorite || default_favorite->update_received())
       << "No update received for: " << default_network->path();
   return default_favorite;
 }
 
 const NetworkState* NetworkStateHandler::ConnectedNetworkByType(
     const NetworkTypePattern& type) const {
   for (ManagedStateList::const_iterator iter = network_list_.begin();
        iter != network_list_.end(); ++iter) {
     const NetworkState* network = (*iter)->AsNetworkState();
@@ skipping 91 matching lines @@
 
 void NetworkStateHandler::GetFavoriteListByType(const NetworkTypePattern& type,
                                                 FavoriteStateList* list) const {
   DCHECK(list);
   FavoriteStateList result;
   list->clear();
   for (ManagedStateList::const_iterator iter = favorite_list_.begin();
        iter != favorite_list_.end(); ++iter) {
     const FavoriteState* favorite = (*iter)->AsFavoriteState();
     DCHECK(favorite);
-    if (favorite->update_received() && favorite->IsFavorite() &&
+    if (favorite->update_received() && favorite->IsInProfile() &&
         favorite->Matches(type)) {
       list->push_back(favorite);
     }
   }
 }
 
-const FavoriteState* NetworkStateHandler::GetFavoriteState(
-    const std::string& service_path) const {
+const FavoriteState* NetworkStateHandler::GetFavoriteStateFromServicePath(
+    const std::string& service_path,
+    bool configured_only) const {
   ManagedState* managed =
       GetModifiableManagedState(&favorite_list_, service_path);
   if (!managed)
     return NULL;
   const FavoriteState* favorite = managed->AsFavoriteState();
   DCHECK(favorite);
-  if (!favorite->update_received() || !favorite->IsFavorite())
+  if (!favorite->update_received() ||
+      (configured_only && !favorite->IsInProfile())) {
     return NULL;
+  }
   return favorite;
 }
 
+const FavoriteState* NetworkStateHandler::GetFavoriteStateFromGuid(
+    const std::string& guid) const {
+  DCHECK(!guid.empty());
+  for (ManagedStateList::const_iterator iter = favorite_list_.begin();
+       iter != favorite_list_.end(); ++iter) {
+    const FavoriteState* favorite = (*iter)->AsFavoriteState();
+    if (favorite->guid() == guid)
+      return favorite;
+  }
+  return NULL;
+}
+
 void NetworkStateHandler::RequestScan() const {
   NET_LOG_USER("RequestScan", "");
   shill_property_handler_->RequestScan();
 }
 
 void NetworkStateHandler::WaitForScan(const std::string& type,
                                       const base::Closure& callback) {
   scan_complete_callbacks_[type].push_back(callback);
   if (!GetScanningByType(NetworkTypePattern::Primitive(type)))
     RequestScan();
@@ skipping 140 matching lines @@
   ManagedState* managed = GetModifiableManagedState(managed_list, path);
   if (!managed) {
     if (type != ManagedState::MANAGED_TYPE_FAVORITE) {
       // The network has been removed from the list of visible networks.
       NET_LOG_DEBUG("UpdateManagedStateProperties: Not found", path);
       return;
     }
     // A Favorite may not have been created yet if it was added later (e.g.
     // through ConfigureService) since ServiceCompleteList updates are not
     // emitted. Add and update the state here.
-    managed = new FavoriteState(path);
+    managed = ManagedState::Create(type, path);
     managed_list->push_back(managed);
   }
   managed->set_update_received();
 
   std::string desc = GetManagedStateLogType(managed) + " Properties Received";
   NET_LOG_DEBUG(desc, GetManagedStateLogName(managed));
 
   if (type == ManagedState::MANAGED_TYPE_NETWORK) {
     UpdateNetworkStateProperties(managed->AsNetworkState(), properties);
   } else {
     // Device, Favorite
     for (base::DictionaryValue::Iterator iter(properties);
          !iter.IsAtEnd(); iter.Advance()) {
       managed->PropertyChanged(iter.key(), iter.value());
     }
     managed->InitialPropertiesReceived(properties);
   }
+  UpdateGuid(managed);
   managed->set_update_requested(false);
 }
 
 void NetworkStateHandler::UpdateNetworkStateProperties(
     NetworkState* network,
     const base::DictionaryValue& properties) {
   DCHECK(network);
   bool network_property_updated = false;
   std::string prev_connection_state = network->connection_state();
   for (base::DictionaryValue::Iterator iter(properties);
@@ skipping 154 matching lines @@
     NET_LOG_DEBUG("FavoriteListChanged",
                   base::StringPrintf("Size:%" PRIuS, favorite_list_.size()));
     // The FavoriteState list only changes when the NetworkState list changes,
     // so no need to signal observers here again.
 
     // Update UMA stats.
     size_t shared = 0, unshared = 0;
     for (ManagedStateList::iterator iter = favorite_list_.begin();
          iter != favorite_list_.end(); ++iter) {
       FavoriteState* favorite = (*iter)->AsFavoriteState();
-      if (!favorite->IsFavorite())
+      if (!favorite->IsInProfile())
         continue;
       if (favorite->IsPrivate())
         ++unshared;
       else
         ++shared;
     }
     UMA_HISTOGRAM_COUNTS_100("Networks.RememberedShared", shared);
     UMA_HISTOGRAM_COUNTS_100("Networks.RememberedUnshared", unshared);
   } else if (type == ManagedState::MANAGED_TYPE_DEVICE) {
     NotifyDeviceListChanged();
@@ skipping 26 matching lines @@
     NET_LOG_ERROR(
         "DefaultNetwork is not connected: " + network->connection_state(),
         network->path());
   }
   NotifyDefaultNetworkChanged(network);
 }
 
 //------------------------------------------------------------------------------
 // Private methods
 
+void NetworkStateHandler::UpdateGuid(ManagedState* managed) {
+  if (managed->managed_type() == ManagedState::MANAGED_TYPE_FAVORITE) {
+    FavoriteState* favorite = managed->AsFavoriteState();
+    std::string specifier = favorite->GetSpecifier();
+    if (!favorite->guid().empty()) {
+      // If the favorite is saved in a profile, remove the entry from the map.
+      // Otherwise ensure that the entry matches the specified GUID.
+      if (favorite->IsInProfile())
+        specifier_guid_map_.erase(specifier);
+      else
+        specifier_guid_map_[specifier] = favorite->guid();
+      return;
+    }
+    // Ensure that the FavoriteState has a valid GUID.
+    std::string guid;
+    SpecifierGuidMap::iterator iter = specifier_guid_map_.find(specifier);
+    if (iter != specifier_guid_map_.end()) {
+      guid = iter->second;
+    } else {
+      guid = base::GenerateGUID();
+      specifier_guid_map_[specifier] = guid;
+    }
+    favorite->SetGuid(guid);
+    NetworkState* network = GetModifiableNetworkState(favorite->path());
+    if (network)
+      network->SetGuid(guid);
+  } else if (managed->managed_type() == ManagedState::MANAGED_TYPE_NETWORK) {
+    // If the GUID is not set and a corresponding FavoriteState exists, get the
+    // GUID from the FavoriteState. Otherwise it will get set when the Favorite
+    // is created.
+    NetworkState* network = managed->AsNetworkState();
+    if (!network->guid().empty())
+      return;
+    FavoriteState* favorite = GetModifiableFavoriteState(network->path());

[pneubeck (no reviews), 2014/05/13 08:43:54]

at least add a log message here if !favorite

[stevenjb, 2014/05/13 18:25:07]

Hmm. I don't want to create log spam here, but in practice it shouldn't happen.
I guess should add a DCHECK until we eliminate NetworkState::guid entirely.

[pneubeck (no reviews), 2014/05/14 08:46:07]

DCHECKs shouldn't be handled (next line with if(favorite..) ) ;-)

On non debug builds you will never find out whether this case occurs.
If it shouldn't happen, why would a log message spam the logs?

+    if (favorite && !favorite->guid().empty())
+      network->SetGuid(favorite->guid());
+  }
+}
+
 void NetworkStateHandler::NotifyDeviceListChanged() {
   NET_LOG_DEBUG("NotifyDeviceListChanged",
                 base::StringPrintf("Size:%" PRIuS, device_list_.size()));
   FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
                     DeviceListChanged());
 }
 
 DeviceState* NetworkStateHandler::GetModifiableDeviceState(
     const std::string& device_path) const {
   ManagedState* managed = GetModifiableManagedState(&device_list_, device_path);
   if (!managed)
     return NULL;
   return managed->AsDeviceState();
 }
 
 NetworkState* NetworkStateHandler::GetModifiableNetworkState(
     const std::string& service_path) const {
   ManagedState* managed =
       GetModifiableManagedState(&network_list_, service_path);
   if (!managed)
     return NULL;
   return managed->AsNetworkState();
 }
 
+FavoriteState* NetworkStateHandler::GetModifiableFavoriteState(
+    const std::string& service_path) const {
+  ManagedState* managed =
+      GetModifiableManagedState(&favorite_list_, service_path);
+  if (!managed)
+    return NULL;
+  return managed->AsFavoriteState();
+}
+
 ManagedState* NetworkStateHandler::GetModifiableManagedState(
     const ManagedStateList* managed_list,
     const std::string& path) const {
   for (ManagedStateList::const_iterator iter = managed_list->begin();
        iter != managed_list->end(); ++iter) {
     ManagedState* managed = *iter;
     if (managed->path() == path)
       return managed;
   }
   return NULL;
@@ skipping 97 matching lines @@
   if (type.MatchesType(shill::kTypeBluetooth))
     technologies.push_back(new std::string(shill::kTypeBluetooth));
   if (type.MatchesType(shill::kTypeVPN))
     technologies.push_back(new std::string(shill::kTypeVPN));
 
   CHECK_GT(technologies.size(), 0ul);
   return technologies.Pass();
 }
 
 }  // namespace chromeos