Add support for MAC address randomization

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 115 matching lines @@
   if (!callback.is_null())
     callback.Run();
 }
 
 void SetDevicePropertyInternal(
     const std::string& device_path,
     const std::string& property_name,
     const base::Value& value,
     const base::Closure& callback,
     const network_handler::ErrorCallback& error_callback) {
   NET_LOG(USER) << "Device.SetProperty: " << property_name;

[Eric Caruso, 2016/06/08 00:43:46]

By which I mean this log line right here.

   DBusThreadManager::Get()->GetShillDeviceClient()->SetProperty(
       dbus::ObjectPath(device_path),
       property_name,
       value,
       callback,
       base::Bind(&HandleShillCallFailure, device_path, error_callback));
 }
 
 // Struct containing TDLS Operation parameters.
 struct TDLSOperationParams {
@@ skipping 278 matching lines @@
       callback,
       base::Bind(&HandleShillCallFailure, device_path, error_callback));
 }
 
 void NetworkDeviceHandlerImpl::SetCellularAllowRoaming(
     const bool allow_roaming) {
   cellular_allow_roaming_ = allow_roaming;
   ApplyCellularAllowRoamingToShill();
 }
 
+void NetworkDeviceHandlerImpl::SetMACAddressRandomizationEnabled(
+    const bool enabled) {

[stevenjb, 2016/06/08 00:35:27]

Can you add a log entry, e.g.:
NET_LOG(USER) << "Device.MACAddressRandomization: " << (enabled ? "True" :
"False");

THanks.

+  mac_addr_randomization_ = 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)
     return;
 
   TDLSOperationParams params;
@@ skipping 68 matching lines @@
       ->GetShillDeviceClient()
       ->RemoveAllWakeOnPacketConnections(dbus::ObjectPath(device_state->path()),
                                          callback,
                                          base::Bind(&HandleShillCallFailure,
                                                     device_state->path(),
                                                     error_callback));
 }
 
 void NetworkDeviceHandlerImpl::DeviceListChanged() {
   ApplyCellularAllowRoamingToShill();
+  ApplyMACAddressRandomizationToShill();
 }
 
 NetworkDeviceHandlerImpl::NetworkDeviceHandlerImpl()
     : network_state_handler_(NULL),
-      cellular_allow_roaming_(false) {}
+      cellular_allow_roaming_(false),
+      mac_addr_randomization_(false) {}
 
 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 19 matching lines @@
       continue;
 
     SetDevicePropertyInternal(device_state->path(),
                               shill::kCellularAllowRoamingProperty,
                               base::FundamentalValue(new_device_value),
                               base::Bind(&base::DoNothing),
                               network_handler::ErrorCallback());
   }
 }
 
+void NetworkDeviceHandlerImpl::ApplyMACAddressRandomizationToShill() {
+  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());
+}
+
 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