chromeos: add dock mac address source handler

Implement dock mac address source handler which changes shill Ethernet
property.

More details about USB Ethernet MAC address source policy
implementaion in shill: go/shill-dock-passthrough.

Bug: b:132240657
TEST=unittests and manual test that shill receive policy on changes
     and chrome startup

Change-Id: Ic3fc7dd416b60294bfcab122ebb64db7f7ea00da
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1700203Reviewed-by: Pavol Marko <pmarko@chromium.org>
Reviewed-by: Steven Bennetts <stevenjb@chromium.org>
Commit-Queue: Oleh Lamzin <lamzin@google.com>
Cr-Commit-Position: refs/heads/master@{#699742}

chrome/browser/chromeos/BUILD.gn

@@ -1646,6 +1646,8 @@ source_set("chromeos") {
     "policy/device_cloud_policy_store_chromeos.h",
     "policy/device_cloud_policy_validator.cc",
     "policy/device_cloud_policy_validator.h",
+    "policy/device_dock_mac_address_source_handler.cc",
+    "policy/device_dock_mac_address_source_handler.h",
     "policy/device_local_account.cc",
     "policy/device_local_account.h",
     "policy/device_local_account_extension_tracker.cc",
@@ -2680,6 +2682,7 @@ source_set("unit_tests") {
     "policy/device_cloud_policy_initializer_unittest.cc",
     "policy/device_cloud_policy_manager_chromeos_unittest.cc",
     "policy/device_cloud_policy_store_chromeos_unittest.cc",
+    "policy/device_dock_mac_address_source_handler_unittest.cc",
     "policy/device_local_account_policy_service_unittest.cc",
     "policy/device_policy_decoder_chromeos_unittest.cc",
     "policy/dm_token_storage_unittest.cc",

chrome/browser/chromeos/policy/browser_policy_connector_chromeos.cc

@@ -28,6 +28,7 @@
 #include "chrome/browser/chromeos/policy/bluetooth_policy_handler.h"
 #include "chrome/browser/chromeos/policy/device_cloud_policy_initializer.h"
 #include "chrome/browser/chromeos/policy/device_cloud_policy_store_chromeos.h"
+#include "chrome/browser/chromeos/policy/device_dock_mac_address_source_handler.h"
 #include "chrome/browser/chromeos/policy/device_local_account.h"
 #include "chrome/browser/chromeos/policy/device_local_account_policy_service.h"
 #include "chrome/browser/chromeos/policy/device_network_configuration_updater.h"
@@ -232,6 +233,11 @@ void BrowserPolicyConnectorChromeOS::Init(
       std::make_unique<MinimumVersionPolicyHandler>(
           chromeos::CrosSettings::Get());
 
+  device_dock_mac_address_source_handler_ =
+      std::make_unique<DeviceDockMacAddressHandler>(
+          chromeos::CrosSettings::Get(),
+          chromeos::NetworkHandler::Get()->network_device_handler());
+
   device_wifi_allowed_handler_ =
       std::make_unique<DeviceWiFiAllowedHandler>(chromeos::CrosSettings::Get());
 

chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h

@@ -43,6 +43,7 @@ class AffiliatedRemoteCommandsInvalidator;
 class BluetoothPolicyHandler;
 class DeviceActiveDirectoryPolicyManager;
 class DeviceCloudPolicyInitializer;
+class DeviceDockMacAddressHandler;
 class DeviceLocalAccountPolicyService;
 class DeviceNetworkConfigurationUpdater;
 class DeviceWiFiAllowedHandler;
@@ -243,6 +244,8 @@ class BrowserPolicyConnectorChromeOS
   std::unique_ptr<BluetoothPolicyHandler> bluetooth_policy_handler_;
   std::unique_ptr<HostnameHandler> hostname_handler_;
   std::unique_ptr<MinimumVersionPolicyHandler> minimum_version_policy_handler_;
+  std::unique_ptr<DeviceDockMacAddressHandler>
+      device_dock_mac_address_source_handler_;
   std::unique_ptr<DeviceWiFiAllowedHandler> device_wifi_allowed_handler_;
   std::unique_ptr<TPMAutoUpdateModePolicyHandler>
       tpm_auto_update_mode_policy_handler_;

chrome/browser/chromeos/policy/device_dock_mac_address_source_handler.cc

+// Copyright 2019 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/policy/device_dock_mac_address_source_handler.h"
+
+#include "base/bind.h"
+#include "base/logging.h"
+#include "chromeos/network/network_device_handler.h"
+#include "chromeos/settings/cros_settings_names.h"
+#include "chromeos/settings/cros_settings_provider.h"
+#include "components/policy/proto/chrome_device_policy.pb.h"
+#include "third_party/cros_system_api/dbus/shill/dbus-constants.h"
+
+namespace em = enterprise_management;
+
+namespace policy {
+
+DeviceDockMacAddressHandler::DeviceDockMacAddressHandler(
+    chromeos::CrosSettings* cros_settings,
+    chromeos::NetworkDeviceHandler* network_device_handler)
+    : cros_settings_(cros_settings),
+      network_device_handler_(network_device_handler) {
+  dock_mac_address_source_policy_subscription_ =
+      cros_settings_->AddSettingsObserver(
+          chromeos::kDeviceDockMacAddressSource,
+          base::BindRepeating(
+              &DeviceDockMacAddressHandler::OnDockMacAddressSourcePolicyChanged,
+              weak_factory_.GetWeakPtr()));
+  // Fire it once so we're sure we get an invocation on startup.
+  OnDockMacAddressSourcePolicyChanged();
+}
+
+DeviceDockMacAddressHandler::~DeviceDockMacAddressHandler() = default;
+
+void DeviceDockMacAddressHandler::OnDockMacAddressSourcePolicyChanged() {
+  // Wait for the |cros_settings_| to become trusted.
+  const chromeos::CrosSettingsProvider::TrustedStatus status =
+      cros_settings_->PrepareTrustedValues(base::BindRepeating(
+          &DeviceDockMacAddressHandler::OnDockMacAddressSourcePolicyChanged,
+          weak_factory_.GetWeakPtr()));
+  if (status != chromeos::CrosSettingsProvider::TRUSTED)
+    return;
+
+  int dock_mac_address_source;
+  if (!cros_settings_->GetInteger(chromeos::kDeviceDockMacAddressSource,
+                                  &dock_mac_address_source)) {
+    return;
+  }
+
+  const char* source = nullptr;
+  switch (dock_mac_address_source) {
+    case em::DeviceDockMacAddressSourceProto::DEVICE_DOCK_MAC_ADDRESS:
+      source = shill::kUsbEthernetMacAddressSourceDesignatedDockMac;
+      break;
+    case em::DeviceDockMacAddressSourceProto::DEVICE_NIC_MAC_ADDRESS:
+      source = shill::kUsbEthernetMacAddressSourceBuiltinAdapterMac;
+      break;
+    case em::DeviceDockMacAddressSourceProto::DOCK_NIC_MAC_ADDRESS:
+      source = shill::kUsbEthernetMacAddressSourceUsbAdapterMac;
+      break;
+    default:
+      LOG(ERROR) << "Unknown dock MAC address source: "
+                 << dock_mac_address_source;
+      return;
+  }
+
+  network_device_handler_->SetUsbEthernetMacAddressSource(source);
+}
+
+}  // namespace policy

chrome/browser/chromeos/policy/device_dock_mac_address_source_handler.h

+// Copyright 2019 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.
+
+#ifndef CHROME_BROWSER_CHROMEOS_POLICY_DEVICE_DOCK_MAC_ADDRESS_SOURCE_HANDLER_H_
+#define CHROME_BROWSER_CHROMEOS_POLICY_DEVICE_DOCK_MAC_ADDRESS_SOURCE_HANDLER_H_
+
+#include <memory>
+
+#include "base/macros.h"
+#include "base/memory/weak_ptr.h"
+#include "chrome/browser/chromeos/settings/cros_settings.h"
+
+namespace chromeos {
+class NetworkDeviceHandler;
+}  // namespace chromeos
+
+namespace policy {
+
+// This class observes the device setting |DeviceDockMacAddressSource|, and
+// updates shill EthernetMacAddressSource property based on this setting.
+class DeviceDockMacAddressHandler {
+ public:
+  DeviceDockMacAddressHandler(
+      chromeos::CrosSettings* cros_settings,
+      chromeos::NetworkDeviceHandler* network_device_handler);
+  ~DeviceDockMacAddressHandler();
+
+ private:
+  void OnDockMacAddressSourcePolicyChanged();
+
+  chromeos::CrosSettings* cros_settings_;
+  chromeos::NetworkDeviceHandler* network_device_handler_;
+  std::unique_ptr<chromeos::CrosSettings::ObserverSubscription>
+      dock_mac_address_source_policy_subscription_;
+  base::WeakPtrFactory<DeviceDockMacAddressHandler> weak_factory_{this};
+
+  DISALLOW_COPY_AND_ASSIGN(DeviceDockMacAddressHandler);
+};
+
+}  // namespace policy
+
+#endif  // CHROME_BROWSER_CHROMEOS_POLICY_DEVICE_DOCK_MAC_ADDRESS_SOURCE_HANDLER_H_

chrome/browser/chromeos/policy/device_dock_mac_address_source_handler_unittest.cc

+// Copyright 2019 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/policy/device_dock_mac_address_source_handler.h"
+
+#include <memory>
+#include <string>
+#include <tuple>
+
+#include "base/macros.h"
+#include "chrome/browser/chromeos/settings/cros_settings.h"
+#include "chrome/browser/chromeos/settings/device_settings_service.h"
+#include "chrome/browser/chromeos/settings/scoped_cros_settings_test_helper.h"
+#include "chromeos/network/mock_network_device_handler.h"
+#include "chromeos/network/network_device_handler.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace policy {
+
+class DeviceDockMacAddressHandlerBaseTest : public testing::Test {
+ public:
+  DeviceDockMacAddressHandlerBaseTest() {
+    scoped_cros_settings_test_helper_.ReplaceDeviceSettingsProviderWithStub();
+    scoped_cros_settings_test_helper_.SetTrustedStatus(
+        chromeos::CrosSettingsProvider::TEMPORARILY_UNTRUSTED);
+
+    device_dock_mac_address_handler_ =
+        std::make_unique<DeviceDockMacAddressHandler>(
+            chromeos::CrosSettings::Get(), &network_device_handler_mock_);
+  }
+
+ protected:
+  void MakeCrosSettingsTrusted() {
+    scoped_cros_settings_test_helper_.SetTrustedStatus(
+        chromeos::CrosSettingsProvider::TRUSTED);
+  }
+
+  chromeos::ScopedCrosSettingsTestHelper scoped_cros_settings_test_helper_;
+
+  testing::StrictMock<chromeos::MockNetworkDeviceHandler>
+      network_device_handler_mock_;
+
+  std::unique_ptr<DeviceDockMacAddressHandler> device_dock_mac_address_handler_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DeviceDockMacAddressHandlerBaseTest);
+};
+
+// Tests that DockMacAddressHandler does not change device handler property if
+// received policy is invalid.
+TEST_F(DeviceDockMacAddressHandlerBaseTest, InvalidPolicyValue) {
+  MakeCrosSettingsTrusted();
+  scoped_cros_settings_test_helper_.SetInteger(
+      chromeos::kDeviceDockMacAddressSource, 4);
+}
+
+class DeviceDockMacAddressHandlerTest
+    : public DeviceDockMacAddressHandlerBaseTest,
+      public testing::WithParamInterface<std::tuple<int, std::string>> {
+ public:
+  DeviceDockMacAddressHandlerTest() = default;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DeviceDockMacAddressHandlerTest);
+};
+
+// Tests that DockMacAddressHandler does not change device handler property if
+// CrosSettings are untrusted.
+TEST_P(DeviceDockMacAddressHandlerTest, OnPolicyChangeUntrusted) {
+  scoped_cros_settings_test_helper_.SetInteger(
+      chromeos::kDeviceDockMacAddressSource, std::get<0>(GetParam()));
+}
+
+// Tests that DockMacAddressHandler changes device handler property if
+// CrosSetting are trusted.
+TEST_P(DeviceDockMacAddressHandlerTest, OnPolicyChange) {
+  MakeCrosSettingsTrusted();
+  EXPECT_CALL(network_device_handler_mock_,
+              SetUsbEthernetMacAddressSource(std::get<1>(GetParam())));
+  scoped_cros_settings_test_helper_.SetInteger(
+      chromeos::kDeviceDockMacAddressSource, std::get<0>(GetParam()));
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    ,
+    DeviceDockMacAddressHandlerTest,
+    testing::Values(std::make_tuple(1, "designated_dock_mac"),
+                    std::make_tuple(2, "builtin_adapter_mac"),
+                    std::make_tuple(3, "usb_adapter_mac")));
+
+}  // namespace policy

chromeos/dbus/shill/fake_shill_device_client.cc

@@ -399,6 +399,33 @@ void FakeShillDeviceClient::RemoveAllWakeOnPacketConnections(
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, callback);
 }
 
+void FakeShillDeviceClient::SetUsbEthernetMacAddressSource(
+    const dbus::ObjectPath& device_path,
+    const std::string& source,
+    const base::Closure& callback,
+    const ErrorCallback& error_callback) {
+  if (!stub_devices_.HasKey(device_path.value())) {
+    PostNotFoundError(error_callback);
+    return;
+  }
+
+  const auto error_name_iter =
+      set_usb_ethernet_mac_address_source_error_names_.find(
+          device_path.value());
+  if (error_name_iter !=
+          set_usb_ethernet_mac_address_source_error_names_.end() &&
+      !error_name_iter->first.empty()) {
+    PostError(error_name_iter->second, error_callback);
+    return;
+  }
+
+  base::Value* properties = GetDeviceProperties(device_path.value());
+  properties->SetKey(shill::kUsbEthernetMacAddressSourceProperty,
+                     base::Value(source));
+
+  base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, callback);
+}
+
 ShillDeviceClient::TestInterface* FakeShillDeviceClient::GetTestInterface() {
   return this;
 }
@@ -515,6 +542,12 @@ void FakeShillDeviceClient::AddCellularFoundNetwork(
                      shill::kFoundNetworksProperty));
 }
 
+void FakeShillDeviceClient::SetUsbEthernetMacAddressSourceError(
+    const std::string& device_path,
+    const std::string& error_name) {
+  set_usb_ethernet_mac_address_source_error_names_[device_path] = error_name;
+}
+
 // Private Methods -------------------------------------------------------------
 
 FakeShillDeviceClient::SimLockStatus FakeShillDeviceClient::GetSimLockStatus(

chromeos/dbus/shill/fake_shill_device_client.h

@@ -95,6 +95,11 @@ class COMPONENT_EXPORT(SHILL_CLIENT) FakeShillDeviceClient
       const dbus::ObjectPath& device_path,
       const base::Closure& callback,
       const ErrorCallback& error_callback) override;
+  void SetUsbEthernetMacAddressSource(
+      const dbus::ObjectPath& device_path,
+      const std::string& source,
+      const base::Closure& callback,
+      const ErrorCallback& error_callback) override;
 
   ShillDeviceClient::TestInterface* GetTestInterface() override;
 
@@ -113,6 +118,9 @@ class COMPONENT_EXPORT(SHILL_CLIENT) FakeShillDeviceClient
   void SetTDLSState(const std::string& state) override;
   void SetSimLocked(const std::string& device_path, bool locked) override;
   void AddCellularFoundNetwork(const std::string& device_path) override;
+  void SetUsbEthernetMacAddressSourceError(
+      const std::string& device_path,
+      const std::string& error_name) override;
 
   static const char kSimPuk[];
   static const char kDefaultSimPin[];
@@ -180,6 +188,12 @@ class COMPONENT_EXPORT(SHILL_CLIENT) FakeShillDeviceClient
   // Current SIM PIN per device path.
   std::map<std::string, std::string> sim_pin_;
 
+  // Error names for SetUsbEthernetMacAddressSource error callback for each
+  // device. Error callback must not be called if error name is not present or
+  // empty.
+  std::map<std::string, std::string>
+      set_usb_ethernet_mac_address_source_error_names_;
+
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate its weak pointers before any other members are destroyed.
   base::WeakPtrFactory<FakeShillDeviceClient> weak_ptr_factory_{this};

chromeos/dbus/shill/shill_device_client.cc

@@ -260,6 +260,21 @@ class ShillDeviceClientImpl : public ShillDeviceClient {
                                           error_callback);
   }
 
+  void SetUsbEthernetMacAddressSource(
+      const dbus::ObjectPath& device_path,
+      const std::string& source,
+      const base::Closure& callback,
+      const ErrorCallback& error_callback) override {
+    dbus::MethodCall method_call(
+        shill::kFlimflamDeviceInterface,
+        shill::kSetUsbEthernetMacAddressSourceFunction);
+    dbus::MessageWriter writer(&method_call);
+    writer.AppendString(source);
+    GetHelper(device_path)
+        ->CallVoidMethodWithErrorCallback(&method_call, callback,
+                                          error_callback);
+  }
+
   TestInterface* GetTestInterface() override { return nullptr; }
 
  private:

chromeos/dbus/shill/shill_device_client.h

@@ -62,6 +62,11 @@ class COMPONENT_EXPORT(SHILL_CLIENT) ShillDeviceClient {
     virtual void SetSimLocked(const std::string& device_path, bool enabled) = 0;
     // Adds a new entry to Cellular.FoundNetworks.
     virtual void AddCellularFoundNetwork(const std::string& device_path) = 0;
+    // Sets error for SetUsbEthernetMacAddressSourceError error callback. Error
+    // callback must be called only if |error_name| is not empty.
+    virtual void SetUsbEthernetMacAddressSourceError(
+        const std::string& device_path,
+        const std::string& error_name) = 0;
 
    protected:
     virtual ~TestInterface() {}
@@ -202,6 +207,15 @@ class COMPONENT_EXPORT(SHILL_CLIENT) ShillDeviceClient {
       const base::Closure& callback,
       const ErrorCallback& error_callback) = 0;
 
+  // Set MAC address source for USB Ethernet adapter. |source| corresponds to
+  // "USB Ethernet MAC address sources." in
+  // third_party/cros_system_api/dbus/shill/dbus-constants.h.
+  virtual void SetUsbEthernetMacAddressSource(
+      const dbus::ObjectPath& device_path,
+      const std::string& source,
+      const base::Closure& callback,
+      const ErrorCallback& error_callback) = 0;
+
   // Returns an interface for testing (stub only), or returns null.
   virtual TestInterface* GetTestInterface() = 0;
 

chromeos/network/device_state.cc

@@ -110,6 +110,10 @@ bool DeviceState::PropertyChanged(const std::string& key,
     // calls to IPConfigPropertiesChanged.
     ip_configs_.Clear();
     return false;  // No actual state change.
+  } else if (key == shill::kLinkUpProperty) {
+    return GetBooleanValue(key, value, &link_up_);
+  } else if (key == shill::kDeviceBusTypeProperty) {
+    return GetStringValue(key, value, &device_bus_type_);
   }
   return false;
 }

chromeos/network/device_state.h

@@ -64,6 +64,8 @@ class COMPONENT_EXPORT(CHROMEOS_NETWORK) DeviceState : public ManagedState {
   bool eap_authentication_completed() const {
     return eap_authentication_completed_;
   }
+  bool link_up() const { return link_up_; }
+  const std::string& device_bus_type() const { return device_bus_type_; }
 
   // WiFi specific accessors
   const std::string& available_managed_network_path() const {
@@ -109,6 +111,8 @@ class COMPONENT_EXPORT(CHROMEOS_NETWORK) DeviceState : public ManagedState {
 
   // Ethernet specific properties
   bool eap_authentication_completed_ = false;
+  bool link_up_ = false;
+  std::string device_bus_type_;
 
   // WiFi specific properties
   std::string available_managed_network_path_;

chromeos/network/fake_network_device_handler.cc

@@ -62,6 +62,9 @@ void FakeNetworkDeviceHandler::ChangePin(
 
 void FakeNetworkDeviceHandler::SetCellularAllowRoaming(bool allow_roaming) {}
 
+void FakeNetworkDeviceHandler::SetUsbEthernetMacAddressSource(
+    const std::string& source) {}
+
 void FakeNetworkDeviceHandler::SetWifiTDLSEnabled(
     const std::string& ip_or_mac_address,
     bool enabled,

chromeos/network/fake_network_device_handler.h

@@ -74,6 +74,8 @@ class COMPONENT_EXPORT(CHROMEOS_NETWORK) FakeNetworkDeviceHandler
 
   void SetCellularAllowRoaming(bool allow_roaming) override;
 
+  void SetUsbEthernetMacAddressSource(const std::string& source) override;
+
   void SetWifiTDLSEnabled(
       const std::string& ip_or_mac_address,
       bool enabled,

chromeos/network/mock_network_device_handler.h

@@ -80,6 +80,9 @@ class COMPONENT_EXPORT(CHROMEOS_NETWORK) MockNetworkDeviceHandler
 
   MOCK_METHOD1(SetMACAddressRandomizationEnabled, void(bool enabled));
 
+  MOCK_METHOD1(SetUsbEthernetMacAddressSource,
+               void(const std::string& enabled));
+
   MOCK_METHOD4(SetWifiTDLSEnabled,
                void(const std::string& ip_or_mac_address,
                     bool enabled,

chromeos/network/network_device_handler.h

@@ -176,6 +176,10 @@ class COMPONENT_EXPORT(CHROMEOS_NETWORK) NetworkDeviceHandler {
   // which become available in the future.
   virtual void SetMACAddressRandomizationEnabled(bool enabled) = 0;
 
+  // Sets up USB Ethernet MAC address source. This applies to primary enabled
+  // USB Ethernet device.
+  virtual void SetUsbEthernetMacAddressSource(const std::string& source) = 0;
+
   // Attempts to enable or disable TDLS for the specified IP or MAC address for
   // the active wifi device.
   virtual void SetWifiTDLSEnabled(

chromeos/network/network_device_handler_impl.cc

@@ -259,6 +259,8 @@ void CallPerformTDLSOperation(
 
 }  // namespace
 
+NetworkDeviceHandlerImpl::NetworkDeviceHandlerImpl() = default;
+
 NetworkDeviceHandlerImpl::~NetworkDeviceHandlerImpl() {
   if (network_state_handler_)
     network_state_handler_->RemoveObserver(this, FROM_HERE);
@@ -378,6 +380,13 @@ void NetworkDeviceHandlerImpl::SetMACAddressRandomizationEnabled(
   ApplyMACAddressRandomizationToShill();
 }
 
+void NetworkDeviceHandlerImpl::SetUsbEthernetMacAddressSource(
+    const std::string& source) {
+  usb_ethernet_mac_address_source_ = source;
+  usb_ethernet_mac_address_source_needs_update_ = true;
+  ApplyUsbEthernetMacAddressSourceToShill();
+}
+
 void NetworkDeviceHandlerImpl::SetWifiTDLSEnabled(
     const std::string& ip_or_mac_address,
     bool enabled,
@@ -490,9 +499,13 @@ void NetworkDeviceHandlerImpl::RemoveAllWifiWakeOnPacketConnections(
 void NetworkDeviceHandlerImpl::DeviceListChanged() {
   ApplyCellularAllowRoamingToShill();
   ApplyMACAddressRandomizationToShill();
+  ApplyUsbEthernetMacAddressSourceToShill();
 }
 
-NetworkDeviceHandlerImpl::NetworkDeviceHandlerImpl() {}
+void NetworkDeviceHandlerImpl::DevicePropertiesUpdated(
+    const DeviceState* device) {
+  ApplyUsbEthernetMacAddressSourceToShill();
+}
 
 void NetworkDeviceHandlerImpl::Init(
     NetworkStateHandler* network_state_handler) {
@@ -561,6 +574,106 @@ void NetworkDeviceHandlerImpl::ApplyMACAddressRandomizationToShill() {
   }
 }
 
+void NetworkDeviceHandlerImpl::ApplyUsbEthernetMacAddressSourceToShill() {
+  const std::string new_primary_enabled_usb_ethernet_device_path =
+      FindPrimaryEnabledUsbEthernetDevicePath();
+  // Restore USB Ethernet MAC address source value to "builtin" at the old
+  // device path if primary enabled USB Ethernet device path has changed.
+  if (new_primary_enabled_usb_ethernet_device_path !=
+          primary_enabled_usb_ethernet_device_path_ &&
+      !primary_enabled_usb_ethernet_device_path_.empty()) {
+    ShillDeviceClient::Get()->SetUsbEthernetMacAddressSource(
+        dbus::ObjectPath(primary_enabled_usb_ethernet_device_path_),
+        shill::kUsbEthernetMacAddressSourceUsbAdapterMac, base::DoNothing(),
+        base::Bind(&HandleShillCallFailure,
+                   primary_enabled_usb_ethernet_device_path_,
+                   network_handler::ErrorCallback()));
+  }
+
+  // Do nothing else if device path and MAC address source have not changed.
+  if (!usb_ethernet_mac_address_source_needs_update_ &&
+      new_primary_enabled_usb_ethernet_device_path ==
+          primary_enabled_usb_ethernet_device_path_) {
+    return;
+  }
+
+  primary_enabled_usb_ethernet_device_path_ =
+      new_primary_enabled_usb_ethernet_device_path;
+  usb_ethernet_mac_address_source_needs_update_ = false;
+
+  const DeviceState* primary_enabled_usb_ethernet_device_state =
+      network_state_handler_->GetDeviceState(
+          primary_enabled_usb_ethernet_device_path_);
+
+  // Do nothing else if device path is empty or device state is nullptr.
+  if (primary_enabled_usb_ethernet_device_path_.empty() ||
+      !primary_enabled_usb_ethernet_device_state) {
+    return;
+  }
+
+  ShillDeviceClient::Get()->SetUsbEthernetMacAddressSource(
+      dbus::ObjectPath(primary_enabled_usb_ethernet_device_path_),
+      usb_ethernet_mac_address_source_, base::DoNothing(),
+      base::Bind(
+          &NetworkDeviceHandlerImpl::OnSetUsbEthernetMacAddressSourceError,
+          weak_ptr_factory_.GetWeakPtr(),
+          primary_enabled_usb_ethernet_device_path_,
+          primary_enabled_usb_ethernet_device_state->mac_address(),
+          network_handler::ErrorCallback()));
+}
+
+void NetworkDeviceHandlerImpl::OnSetUsbEthernetMacAddressSourceError(
+    const std::string& device_path,
+    const std::string& device_mac_address,
+    const network_handler::ErrorCallback& error_callback,
+    const std::string& shill_error_name,
+    const std::string& shill_error_message) {
+  mac_address_change_not_supported_.insert(device_mac_address);
+  HandleShillCallFailure(device_path, error_callback, shill_error_name,
+                         shill_error_message);
+  ApplyUsbEthernetMacAddressSourceToShill();
+}
+
+bool NetworkDeviceHandlerImpl::IsUsbEnabledDevice(
+    const DeviceState* device_state) const {
+  return device_state && device_state->link_up() &&
+         device_state->Matches(NetworkTypePattern::Ethernet()) &&
+         device_state->device_bus_type() == shill::kDeviceBusTypeUsb &&
+         mac_address_change_not_supported_.find(device_state->mac_address()) ==
+             mac_address_change_not_supported_.end();
+}
+
+std::string NetworkDeviceHandlerImpl::FindPrimaryEnabledUsbEthernetDevicePath()
+    const {
+  NetworkStateHandler::DeviceStateList device_state_list;
+  network_state_handler_->GetDeviceListByType(NetworkTypePattern::Ethernet(),
+                                              &device_state_list);
+
+  // Try to avoid situation when both PCI and USB Ethernet devices are enabled
+  // and have the same MAC address. In this situation we will change back USB
+  // Ethernet MAC address.
+  if (usb_ethernet_mac_address_source_ ==
+      shill::kUsbEthernetMacAddressSourceBuiltinAdapterMac) {
+    for (const auto* device_state : device_state_list) {
+      if (device_state && device_state->link_up() &&
+          device_state->device_bus_type() == shill::kDeviceBusTypePci) {
+        return "";
+      }
+    }
+  }
+
+  if (IsUsbEnabledDevice(network_state_handler_->GetDeviceState(
+          primary_enabled_usb_ethernet_device_path_))) {
+    return primary_enabled_usb_ethernet_device_path_;
+  }
+
+  for (const auto* device_state : device_state_list) {
+    if (IsUsbEnabledDevice(device_state))
+      return device_state->path();
+  }
+  return "";
+}
+
 void NetworkDeviceHandlerImpl::HandleMACAddressRandomization(
     const std::string& device_path,
     const base::DictionaryValue& properties) {
@@ -591,12 +704,12 @@ const DeviceState* NetworkDeviceHandlerImpl::GetWifiDeviceState(
       network_state_handler_->GetDeviceStateByType(NetworkTypePattern::WiFi());
   if (!device_state) {
     if (error_callback.is_null())
-      return NULL;
+      return nullptr;
     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 nullptr;
   }
 
   return device_state;

chromeos/network/network_device_handler_impl.h

@@ -5,8 +5,8 @@
 #ifndef CHROMEOS_NETWORK_NETWORK_DEVICE_HANDLER_IMPL_H_
 #define CHROMEOS_NETWORK_NETWORK_DEVICE_HANDLER_IMPL_H_
 
-#include <map>
 #include <string>
+#include <unordered_set>
 #include <vector>
 
 #include "base/callback.h"
@@ -82,6 +82,8 @@ class COMPONENT_EXPORT(CHROMEOS_NETWORK) NetworkDeviceHandlerImpl
 
   void SetMACAddressRandomizationEnabled(bool enabled) override;
 
+  void SetUsbEthernetMacAddressSource(const std::string& source) override;
+
   void SetWifiTDLSEnabled(
       const std::string& ip_or_mac_address,
       bool enabled,
@@ -119,6 +121,7 @@ class COMPONENT_EXPORT(CHROMEOS_NETWORK) NetworkDeviceHandlerImpl
 
   // NetworkStateHandlerObserver overrides
   void DeviceListChanged() override;
+  void DevicePropertiesUpdated(const DeviceState* device) override;
 
  private:
   friend class NetworkHandler;
@@ -149,6 +152,23 @@ class COMPONENT_EXPORT(CHROMEOS_NETWORK) NetworkDeviceHandlerImpl
   // devices.
   void ApplyMACAddressRandomizationToShill();
 
+  // Apply the current value of |usb_ethernet_mac_address_source_| to primary
+  // enabled USB Ethernet device.
+  void ApplyUsbEthernetMacAddressSourceToShill();
+
+  void OnSetUsbEthernetMacAddressSourceError(
+      const std::string& device_path,
+      const std::string& device_mac_address,
+      const network_handler::ErrorCallback& error_callback,
+      const std::string& shill_error_name,
+      const std::string& shill_error_message);
+
+  // Checks whether Device is enabled USB Ethernet adapter.
+  bool IsUsbEnabledDevice(const DeviceState* device_state) const;
+
+  // Returns path for primary enabled USB Ethernet device.
+  std::string FindPrimaryEnabledUsbEthernetDevicePath() const;
+
   // Sets the value of |mac_addr_randomization_supported_| based on
   // whether shill thinks it is supported on the wifi device. If it is
   // supported, also apply |mac_addr_randomization_enabled_| to the
@@ -165,6 +185,14 @@ class COMPONENT_EXPORT(CHROMEOS_NETWORK) NetworkDeviceHandlerImpl
   MACAddressRandomizationSupport mac_addr_randomization_supported_ =
       MACAddressRandomizationSupport::NOT_REQUESTED;
   bool mac_addr_randomization_enabled_ = false;
+
+  std::string usb_ethernet_mac_address_source_;
+  bool usb_ethernet_mac_address_source_needs_update_ = false;
+  std::string primary_enabled_usb_ethernet_device_path_;
+  // Set of device's MAC addresses that do not support MAC address change. Use
+  // MAC address as unique device identifier, because link name can change.
+  std::unordered_set<std::string> mac_address_change_not_supported_;
+
   base::WeakPtrFactory<NetworkDeviceHandlerImpl> weak_ptr_factory_{this};
 
   DISALLOW_COPY_AND_ASSIGN(NetworkDeviceHandlerImpl);