Add recursive sysfs lookup

- For vivaldi we need to traverse up the path looking for the
  attribute that defines the top row mapping.
- Simple helper function that walks up until it finds the key or
  no more parents.
- Add additional tests to UdevTest

BUG=1076241
TEST=device_unittests --gtestfilter='UdevTest.*'

Change-Id: I1ead2c3ecefbe1ef27408b4393cce2aa8ab9be06
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2170852
Commit-Queue: Reilly Grant <reillyg@chromium.org>
Reviewed-by: Reilly Grant <reillyg@chromium.org>
Cr-Commit-Position: refs/heads/master@{#764444}

Author: Zentaro Kavanagh

device/BUILD.gn

@@ -180,7 +180,10 @@ test("device_unittests") {
 
   if (use_udev) {
     sources += [ "udev_linux/udev_unittest.cc" ]
-    deps += [ "//device/udev_linux" ]
+    deps += [
+      "//device/udev_linux",
+      "//device/udev_linux:test_support",
+    ]
   }
 
   if (is_android) {

device/udev_linux/fake_udev_loader.cc

@@ -5,6 +5,7 @@
 #include "device/udev_linux/fake_udev_loader.h"
 
 #include <base/logging.h>
+#include "base/files/file_path.h"
 
 struct udev {
   // empty
@@ -46,14 +47,15 @@ FakeUdevLoader::~FakeUdevLoader() {
     UdevLoader::SetForTesting(nullptr, false);
 }
 
-void FakeUdevLoader::AddFakeDevice(
+udev_device* FakeUdevLoader::AddFakeDevice(
     std::string name,
     std::string syspath,
     std::map<std::string, std::string> sysattrs,
     std::map<std::string, std::string> properties) {
   devices_.emplace_back(new udev_device(std::move(name), std::move(syspath),
                                         std::move(sysattrs),
                                         std::move(properties)));
+  return devices_.back().get();
 }
 
 bool FakeUdevLoader::Init() {
@@ -69,7 +71,16 @@ const char* FakeUdevLoader::udev_device_get_devnode(udev_device* udev_device) {
 }
 
 udev_device* FakeUdevLoader::udev_device_get_parent(udev_device* udev_device) {
-  return nullptr;
+  if (!udev_device) {
+    return nullptr;
+  }
+
+  const base::FilePath syspath(udev_device->syspath_);
+  auto it =
+      std::find_if(devices_.begin(), devices_.end(), [syspath](const auto& d) {
+        return base::FilePath(d->syspath_).IsParent(syspath);
+      });
+  return it == devices_.end() ? nullptr : it->get();
 }
 
 udev_device* FakeUdevLoader::udev_device_get_parent_with_subsystem_devtype(

device/udev_linux/fake_udev_loader.h

@@ -20,10 +20,10 @@ class FakeUdevLoader : public device::UdevLoader {
   FakeUdevLoader();
   ~FakeUdevLoader() override;
 
-  void AddFakeDevice(std::string name,
-                     std::string syspath,
-                     std::map<std::string, std::string> sysattrs,
-                     std::map<std::string, std::string> properties);
+  udev_device* AddFakeDevice(std::string name,
+                             std::string syspath,
+                             std::map<std::string, std::string> sysattrs,
+                             std::map<std::string, std::string> properties);
 
  private:
   bool Init() override;

device/udev_linux/udev.cc

@@ -167,6 +167,20 @@ std::string UdevDeviceGetSysattrValue(udev_device* udev_device,
   return StringOrEmptyIfNull(udev_device_get_sysattr_value(udev_device, key));
 }
 
+std::string UdevDeviceRecursiveGetSysattrValue(udev_device* udev_device,
+                                               const char* key) {
+  while (udev_device) {
+    const char* result = udev_device_get_sysattr_value(udev_device, key);
+    if (result) {
+      return result;
+    }
+
+    udev_device = udev_device_get_parent(udev_device);
+  }
+
+  return "";
+}
+
 std::string UdevDecodeString(const std::string& encoded) {
   std::string decoded;
   const size_t size = encoded.size();

device/udev_linux/udev.h

@@ -84,6 +84,11 @@ std::string UdevDeviceGetPropertyValue(udev_device* udev_device,
 std::string UdevDeviceGetSysattrValue(udev_device* udev_device,
                                       const char* key);
 
+// Walks up the chain of parent devices calling udev_device_get_sysattr_value()
+// until a value is found. If no value is found, an empty string is returned.
+std::string UdevDeviceRecursiveGetSysattrValue(udev_device* udev_device,
+                                               const char* key);
+
 // Decodes udev-encoded string. Useful for decoding "*_ENC" udev properties.
 std::string UdevDecodeString(const std::string& encoded);
 

device/udev_linux/udev_unittest.cc

@@ -3,6 +3,9 @@
 // found in the LICENSE file.
 
 #include "device/udev_linux/udev.h"
+
+#include "base/files/file_path.h"
+#include "device/udev_linux/fake_udev_loader.h"
 #include "device/udev_linux/udev_loader.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
@@ -23,4 +26,54 @@ TEST(UdevTest, Loader) {
   ASSERT_NE(nullptr, UdevLoader::Get());
 }
 
+TEST(UdevTest, GetSysAttrNoAttrs) {
+  testing::FakeUdevLoader fake_udev;
+  udev_device* device = fake_udev.AddFakeDevice("Foo", "/device/foo", {}, {});
+
+  const std::string attr_value = UdevDeviceGetSysattrValue(device, "attr");
+  EXPECT_TRUE(attr_value.empty());
+}
+
+TEST(UdevTest, GetSysAttrSimple) {
+  testing::FakeUdevLoader fake_udev;
+  std::map<std::string, std::string> attrs;
+  attrs.emplace("attr", "attr value");
+  udev_device* device =
+      fake_udev.AddFakeDevice("Foo", "/device/foo", std::move(attrs), {});
+
+  std::string attr_value = UdevDeviceGetSysattrValue(device, "attr");
+  EXPECT_EQ("attr value", attr_value);
+
+  attr_value = UdevDeviceGetSysattrValue(device, "unknown attr");
+  EXPECT_TRUE(attr_value.empty());
+}
+
+TEST(UdevTest, GetParent) {
+  testing::FakeUdevLoader fake_udev;
+  std::map<std::string, std::string> attrs;
+  udev_device* parent = fake_udev.AddFakeDevice("Foo", "/device/foo", {}, {});
+  udev_device* device =
+      fake_udev.AddFakeDevice("Foo", "/device/foo/bar", {}, {});
+
+  EXPECT_EQ(parent, udev_device_get_parent(device));
+  EXPECT_EQ(nullptr, udev_device_get_parent(parent));
+}
+
+TEST(UdevTest, GetSysAttrRecursiveOneLevel) {
+  testing::FakeUdevLoader fake_udev;
+  std::map<std::string, std::string> attrs;
+  attrs.emplace("attr", "attr value");
+  fake_udev.AddFakeDevice("Foo", "/device/foo", std::move(attrs), {});
+  udev_device* device =
+      fake_udev.AddFakeDevice("Foo", "/device/foo/bar", {}, {});
+
+  // Don't find the attr on the current device.
+  std::string attr_value = UdevDeviceGetSysattrValue(device, "attr");
+  EXPECT_TRUE(attr_value.empty());
+
+  // Find it when searching recursive.
+  attr_value = UdevDeviceRecursiveGetSysattrValue(device, "attr");
+  EXPECT_EQ("attr value", attr_value);
+}
+
 }  // namespace device