Don't set MAC address randomization when unsupported

chromeos/network/network_device_handler_impl.cc

 // Copyright 2013 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_device_handler_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <utility>
 
@@ skipping 416 matching lines @@
 }
 
 void NetworkDeviceHandlerImpl::SetCellularAllowRoaming(
     const bool allow_roaming) {
   cellular_allow_roaming_ = allow_roaming;
   ApplyCellularAllowRoamingToShill();
 }
 
 void NetworkDeviceHandlerImpl::SetMACAddressRandomizationEnabled(
     const bool enabled) {
-  mac_addr_randomization_ = enabled;
+  mac_addr_randomization_enabled_ = enabled;
   ApplyMACAddressRandomizationToShill();
 }
 
 void NetworkDeviceHandlerImpl::SetWifiTDLSEnabled(
     const std::string& ip_or_mac_address,
     bool enabled,
     const network_handler::StringResultCallback& callback,
     const network_handler::ErrorCallback& error_callback) {
   const DeviceState* device_state = GetWifiDeviceState(error_callback);
   if (!device_state)
@@ skipping 77 matching lines @@
 }
 
 void NetworkDeviceHandlerImpl::DeviceListChanged() {
   ApplyCellularAllowRoamingToShill();
   ApplyMACAddressRandomizationToShill();
 }
 
 NetworkDeviceHandlerImpl::NetworkDeviceHandlerImpl()
     : network_state_handler_(NULL),
       cellular_allow_roaming_(false),
-      mac_addr_randomization_(false) {}
+      mac_addr_randomization_supported_(true),
+      mac_addr_randomization_enabled_(false),
+      weak_ptr_factory_(this) {}
 
 void NetworkDeviceHandlerImpl::Init(
     NetworkStateHandler* network_state_handler) {
   DCHECK(network_state_handler);
   network_state_handler_ = network_state_handler;
   network_state_handler_->AddObserver(this, FROM_HERE);
 }
 
 void NetworkDeviceHandlerImpl::ApplyCellularAllowRoamingToShill() {
   NetworkStateHandler::DeviceStateList list;
@@ skipping 20 matching lines @@
 
     SetDevicePropertyInternal(device_state->path(),
                               shill::kCellularAllowRoamingProperty,
                               base::FundamentalValue(new_device_value),
                               base::Bind(&base::DoNothing),
                               network_handler::ErrorCallback());
   }
 }
 
 void NetworkDeviceHandlerImpl::ApplyMACAddressRandomizationToShill() {
+  if (!mac_addr_randomization_supported_)
+    return;
+
   const DeviceState* device_state =
       GetWifiDeviceState(network_handler::ErrorCallback());
   if (!device_state)
     return;
 
-  SetDevicePropertyInternal(device_state->path(),
-                            shill::kMACAddressRandomizationProperty,
-                            base::FundamentalValue(mac_addr_randomization_),
-                            base::Bind(&base::DoNothing),
-                            network_handler::ErrorCallback());
+  SetDevicePropertyInternal(
+      device_state->path(), shill::kMACAddressRandomizationProperty,
+      base::FundamentalValue(mac_addr_randomization_enabled_),
+      base::Bind(&base::DoNothing),
+      base::Bind(
+          &NetworkDeviceHandlerImpl::SetMACAddressRandomizationErrorCallback,
+          weak_ptr_factory_.GetWeakPtr()));
+}
+
+void NetworkDeviceHandlerImpl::SetMACAddressRandomizationErrorCallback(
+    const std::string& error_name,
+    std::unique_ptr<base::DictionaryValue> error_data) {
+  if (error_name == NetworkDeviceHandler::kErrorNotSupported)
+    mac_addr_randomization_supported_ = false;
 }
 
 const DeviceState* NetworkDeviceHandlerImpl::GetWifiDeviceState(
     const network_handler::ErrorCallback& error_callback) {
   const DeviceState* device_state =
       network_state_handler_->GetDeviceStateByType(NetworkTypePattern::WiFi());
   if (!device_state) {
     if (error_callback.is_null())
       return NULL;
     std::unique_ptr<base::DictionaryValue> error_data(
         new base::DictionaryValue);
     error_data->SetString(network_handler::kErrorName, kErrorDeviceMissing);
     error_callback.Run(kErrorDeviceMissing, std::move(error_data));
     return NULL;
   }
 
   return device_state;
 }
 
 }  // namespace chromeos