[DeviceService] Expose SerialDeviceEnumerator interface from Device Service

This CL is part of servicification work for //device/serial, it:
 - creates a new mojo interface SerialDeviceEnumerator and exposes it
   from Device Service, the interface implementation wraps
   a device::SerialDeviceEnumerator to do actual work.
 - lets serial extension API impls consume the above interface instead
   of directly calling functions of device::SerialDeviceEnumerator.

BUG=749514
TEST=browser_tests SerialApiTest.*

Change-Id: Ib768bb25032fcc4a0899780a2f85467f128a6800
Reviewed-on: https://chromium-review.googlesource.com/586632Reviewed-by: Reilly Grant <reillyg@chromium.org>
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Reviewed-by: Colin Blundell <blundell@chromium.org>
Commit-Queue: Han Leon <leon.han@intel.com>
Cr-Commit-Position: refs/heads/master@{#491942}

chrome/test/data/extensions/api_test/serial/real_hardware/background.js

@@ -4,10 +4,9 @@
 
 var testGetDevices = function() {
   var onGetDevices = function(devices) {
-    // Any length is potentially valid, because we're on unknown hardware. But
-    // we are testing at least that the devices member was filled in, so it's
-    // still a somewhat meaningful test.
-    chrome.test.assertTrue(devices.length >= 0);
+    chrome.test.assertTrue(devices.length == 2);
+    chrome.test.assertEq('/dev/fakeserialmojo', devices[0].path);
+    chrome.test.assertEq('\\\\COM800\\', devices[1].path);
     chrome.test.succeed();
   }
 

chrome/test/data/extensions/api_test/serial/real_hardware_fail/background.js

+// Copyright (c) 2017 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.
+
+var testGetDevices = function() {
+  var onGetDevices = function(devices) {
+    chrome.test.assertTrue(devices.length == 0);
+    chrome.test.succeed();
+  }
+
+  chrome.serial.getDevices(onGetDevices);
+};
+
+var tests = [testGetDevices];
+chrome.test.runTests(tests);

chrome/test/data/extensions/api_test/serial/real_hardware_fail/manifest.json

+{
+  "name": "chrome.serial.getDevices failure test",
+  "version": "0.1",
+  "description": "end-to-end test getDevices returns empty list for failure",
+  "app": {
+    "background": {
+      "scripts": ["background.js"]
+    }
+  },
+  "permissions": [
+    "serial"
+  ]
+}

content/public/app/mojo/content_browser_manifest.json

@@ -79,6 +79,7 @@
         "device": [
           "device:generic_sensor",
           "device:nfc",
+          "device:serial",
           "device:vibration",
           "device:wake_lock"
         ],

device/serial/BUILD.gn

@@ -6,84 +6,86 @@ import("//build/config/features.gni")
 import("//mojo/public/tools/bindings/mojom.gni")
 
 # Library works only on desktop platforms.
-assert(is_win || is_linux || is_mac)
-
-config("platform_support") {
-  visibility = [ ":serial" ]
-  if (is_win) {
-    libs = [ "setupapi.lib" ]
-    ldflags = [ "/DELAYLOAD:setupapi.dll" ]
+if (is_win || is_linux || is_mac) {
+  config("platform_support") {
+    visibility = [ ":serial" ]
+    if (is_win) {
+      libs = [ "setupapi.lib" ]
+      ldflags = [ "/DELAYLOAD:setupapi.dll" ]
+    }
   }
-}
 
-static_library("serial") {
-  output_name = "device_serial"
+  static_library("serial") {
+    output_name = "device_serial"
 
-  sources = [
-    "buffer.cc",
-    "buffer.h",
-    "serial_device_enumerator.cc",
-    "serial_device_enumerator.h",
-    "serial_device_enumerator_linux.cc",
-    "serial_device_enumerator_linux.h",
-    "serial_device_enumerator_mac.cc",
-    "serial_device_enumerator_mac.h",
-    "serial_device_enumerator_win.cc",
-    "serial_device_enumerator_win.h",
-    "serial_io_handler.cc",
-    "serial_io_handler.h",
-    "serial_io_handler_posix.cc",
-    "serial_io_handler_posix.h",
-    "serial_io_handler_win.cc",
-    "serial_io_handler_win.h",
-  ]
+    sources = [
+      "buffer.cc",
+      "buffer.h",
+      "serial_device_enumerator.cc",
+      "serial_device_enumerator.h",
+      "serial_device_enumerator_linux.cc",
+      "serial_device_enumerator_linux.h",
+      "serial_device_enumerator_mac.cc",
+      "serial_device_enumerator_mac.h",
+      "serial_device_enumerator_win.cc",
+      "serial_device_enumerator_win.h",
+      "serial_io_handler.cc",
+      "serial_io_handler.h",
+      "serial_io_handler_posix.cc",
+      "serial_io_handler_posix.h",
+      "serial_io_handler_win.cc",
+      "serial_io_handler_win.h",
+    ]
 
-  public_configs = [ ":platform_support" ]
+    public_configs = [ ":platform_support" ]
 
-  public_deps = [
-    ":serial_mojo",
-    "//base",
-    "//device/base",
-  ]
+    public_deps = [
+      ":serial_mojo",
+      "//base",
+      "//device/base",
+    ]
 
-  deps = [
-    "//mojo/public/cpp/system",
-    "//net",
-    "//third_party/re2",
-  ]
+    deps = [
+      "//mojo/public/cpp/system",
+      "//net",
+      "//third_party/re2",
+    ]
 
-  if (use_udev) {
-    deps += [ "//device/udev_linux" ]
+    if (use_udev) {
+      deps += [ "//device/udev_linux" ]
+    }
+    if (is_chromeos) {
+      deps += [
+        "//chromeos",
+        "//dbus",
+      ]
+    }
+    if (is_mac) {
+      libs = [
+        "Foundation.framework",
+        "IOKit.framework",
+      ]
+    }
   }
-  if (is_chromeos) {
-    deps += [
-      "//chromeos",
-      "//dbus",
+
+  static_library("test_support") {
+    sources = [
+      "test_serial_io_handler.cc",
+      "test_serial_io_handler.h",
     ]
-  }
-  if (is_mac) {
-    libs = [
-      "Foundation.framework",
-      "IOKit.framework",
+
+    public_deps = [
+      ":serial",
     ]
   }
 }
 
-static_library("test_support") {
-  sources = [
-    "test_serial_io_handler.cc",
-    "test_serial_io_handler.h",
-  ]
-
-  public_deps = [
-    ":serial",
-  ]
-}
-
 mojom("serial_mojo") {
   visibility = [
     ":serial",
     "//extensions:extensions_renderer_resources_grit",
+    "//services/device/public/interfaces",
+    "//services/device/public/interfaces:interfaces_blink",
   ]
 
   sources = [

extensions/browser/api/serial/BUILD.gn

@@ -18,8 +18,12 @@ source_set("serial") {
   ]
 
   deps = [
+    "//content/public/common",
     "//device/serial",
     "//extensions/common/api",
+    "//mojo/public/cpp/bindings",
+    "//services/device/public/interfaces",
+    "//services/service_manager/public/cpp",
   ]
 
   public_deps = [

extensions/browser/api/serial/serial_api.cc

@@ -11,10 +11,14 @@
 #include "base/values.h"
 #include "build/build_config.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/common/service_manager_connection.h"
 #include "device/serial/serial_device_enumerator.h"
 #include "extensions/browser/api/serial/serial_connection.h"
 #include "extensions/browser/api/serial/serial_event_dispatcher.h"
 #include "extensions/common/api/serial.h"
+#include "mojo/public/cpp/bindings/interface_request.h"
+#include "services/device/public/interfaces/constants.mojom.h"
+#include "services/service_manager/public/cpp/connector.h"
 
 using content::BrowserThread;
 
@@ -76,21 +80,29 @@ void SerialAsyncApiFunction::RemoveSerialConnection(int api_resource_id) {
 
 SerialGetDevicesFunction::SerialGetDevicesFunction() {}
 
-bool SerialGetDevicesFunction::Prepare() {
-  set_work_task_runner(base::CreateSequencedTaskRunnerWithTraits(
-      {base::MayBlock(), base::TaskPriority::BACKGROUND}));
-  return true;
-}
-
-void SerialGetDevicesFunction::Work() {
-  DCHECK(work_task_runner()->RunsTasksInCurrentSequence());
-
-  std::unique_ptr<device::SerialDeviceEnumerator> enumerator =
-      device::SerialDeviceEnumerator::Create();
-  std::vector<device::mojom::SerialDeviceInfoPtr> devices =
-      enumerator->GetDevices();
-  results_ = serial::GetDevices::Results::Create(
-      mojo::ConvertTo<std::vector<serial::DeviceInfo>>(devices));
+SerialGetDevicesFunction::~SerialGetDevicesFunction() {}
+
+ExtensionFunction::ResponseAction SerialGetDevicesFunction::Run() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK(content::ServiceManagerConnection::GetForProcess());
+  content::ServiceManagerConnection::GetForProcess()
+      ->GetConnector()
+      ->BindInterface(device::mojom::kServiceName,
+                      mojo::MakeRequest(&enumerator_));
+  enumerator_.set_connection_error_handler(
+      base::BindOnce(&SerialGetDevicesFunction::OnGotDevices, this,
+                     std::vector<device::mojom::SerialDeviceInfoPtr>()));
+  enumerator_->GetDevices(
+      base::BindOnce(&SerialGetDevicesFunction::OnGotDevices, this));
+  return RespondLater();
+}
+
+void SerialGetDevicesFunction::OnGotDevices(
+    std::vector<device::mojom::SerialDeviceInfoPtr> devices) {
+  std::unique_ptr<base::ListValue> results =
+      serial::GetDevices::Results::Create(
+          mojo::ConvertTo<std::vector<serial::DeviceInfo>>(devices));
+  Respond(ArgumentList(std::move(results)));
 }
 
 SerialConnectFunction::SerialConnectFunction() {}

extensions/browser/api/serial/serial_api.h

@@ -11,6 +11,7 @@
 #include "extensions/browser/api/api_resource_manager.h"
 #include "extensions/browser/api/async_api_function.h"
 #include "extensions/common/api/serial.h"
+#include "services/device/public/interfaces/serial.mojom.h"
 
 namespace extensions {
 
@@ -37,18 +38,24 @@ class SerialAsyncApiFunction : public AsyncApiFunction {
   ApiResourceManager<SerialConnection>* manager_;
 };
 
-class SerialGetDevicesFunction : public SerialAsyncApiFunction {
+class SerialGetDevicesFunction : public UIThreadExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("serial.getDevices", SERIAL_GETDEVICES)
 
   SerialGetDevicesFunction();
 
  protected:
-  ~SerialGetDevicesFunction() override {}
+  ~SerialGetDevicesFunction() override;
 
-  // AsyncApiFunction:
-  bool Prepare() override;
-  void Work() override;
+  // ExtensionFunction:
+  ResponseAction Run() override;
+
+ private:
+  void OnGotDevices(std::vector<device::mojom::SerialDeviceInfoPtr> devices);
+
+  device::mojom::SerialDeviceEnumeratorPtr enumerator_;
+
+  DISALLOW_COPY_AND_ASSIGN(SerialGetDevicesFunction);
 };
 
 class SerialConnectFunction : public SerialAsyncApiFunction {

extensions/browser/api/serial/serial_apitest.cc

@@ -9,7 +9,6 @@
 #include "base/macros.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "content/public/browser/browser_thread.h"
-#include "device/serial/serial_device_enumerator.h"
 #include "device/serial/test_serial_io_handler.h"
 #include "extensions/browser/api/serial/serial_api.h"
 #include "extensions/browser/api/serial/serial_connection.h"
@@ -18,6 +17,10 @@
 #include "extensions/common/api/serial.h"
 #include "extensions/common/switches.h"
 #include "extensions/test/result_catcher.h"
+#include "mojo/public/cpp/bindings/strong_binding.h"
+#include "services/device/public/interfaces/constants.mojom.h"
+#include "services/device/public/interfaces/serial.mojom.h"
+#include "services/service_manager/public/cpp/service_context.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using testing::_;
@@ -26,41 +29,26 @@ using testing::Return;
 namespace extensions {
 namespace {
 
-class FakeSerialGetDevicesFunction : public AsyncExtensionFunction {
+class FakeSerialDeviceEnumerator
+    : public device::mojom::SerialDeviceEnumerator {
  public:
-  bool RunAsync() override {
-    std::unique_ptr<base::ListValue> devices(new base::ListValue());
-    std::unique_ptr<base::DictionaryValue> device0(new base::DictionaryValue());
-    device0->SetString("path", "/dev/fakeserial");
-    std::unique_ptr<base::DictionaryValue> device1(new base::DictionaryValue());
-    device1->SetString("path", "\\\\COM800\\");
-    devices->Append(std::move(device0));
-    devices->Append(std::move(device1));
-    SetResult(std::move(devices));
-    SendResponse(true);
-    return true;
-  }
-
- protected:
-  ~FakeSerialGetDevicesFunction() override {}
-};
-
-class FakeSerialDeviceEnumerator : public device::SerialDeviceEnumerator {
- public:
-  ~FakeSerialDeviceEnumerator() override {}
+  FakeSerialDeviceEnumerator() = default;
+  ~FakeSerialDeviceEnumerator() override = default;
 
-  std::vector<device::mojom::SerialDeviceInfoPtr> GetDevices() override {
+ private:
+  // device::mojom::SerialDeviceEnumerator methods:
+  void GetDevices(GetDevicesCallback callback) override {
     std::vector<device::mojom::SerialDeviceInfoPtr> devices;
-    device::mojom::SerialDeviceInfoPtr device0(
-        device::mojom::SerialDeviceInfo::New());
+    auto device0 = device::mojom::SerialDeviceInfo::New();
     device0->path = "/dev/fakeserialmojo";
-    device::mojom::SerialDeviceInfoPtr device1(
-        device::mojom::SerialDeviceInfo::New());
+    auto device1 = device::mojom::SerialDeviceInfo::New();
     device1->path = "\\\\COM800\\";
     devices.push_back(std::move(device0));
     devices.push_back(std::move(device1));
-    return devices;
+    std::move(callback).Run(std::move(devices));
   }
+
+  DISALLOW_COPY_AND_ASSIGN(FakeSerialDeviceEnumerator);
 };
 
 class FakeEchoSerialIoHandler : public device::TestSerialIoHandler {
@@ -104,6 +92,19 @@ class FakeSerialConnectFunction : public api::SerialConnectFunction {
   ~FakeSerialConnectFunction() override {}
 };
 
+void BindSerialDeviceEnumerator(
+    const std::string& interface_name,
+    mojo::ScopedMessagePipeHandle handle,
+    const service_manager::BindSourceInfo& source_info) {
+  mojo::MakeStrongBinding(
+      base::MakeUnique<FakeSerialDeviceEnumerator>(),
+      device::mojom::SerialDeviceEnumeratorRequest(std::move(handle)));
+}
+
+void DropBindRequest(const std::string& interface_name,
+                     mojo::ScopedMessagePipeHandle handle,
+                     const service_manager::BindSourceInfo& source_info) {}
+
 class SerialApiTest : public ExtensionApiTest {
  public:
   SerialApiTest() {}
@@ -112,15 +113,23 @@ class SerialApiTest : public ExtensionApiTest {
     ExtensionApiTest::SetUpCommandLine(command_line);
   }
 
+  void SetUpOnMainThread() override {
+    ExtensionApiTest::SetUpOnMainThread();
+
+    // Because Device Service also runs in this process(browser process), we can
+    // set our binder to intercept requests for SerialDeviceEnumerator interface
+    // to it.
+    service_manager::ServiceContext::SetGlobalBinderForTesting(
+        device::mojom::kServiceName,
+        device::mojom::SerialDeviceEnumerator::Name_,
+        base::Bind(&BindSerialDeviceEnumerator));
+  }
+
   void TearDownOnMainThread() override {
     ExtensionApiTest::TearDownOnMainThread();
   }
 };
 
-ExtensionFunction* FakeSerialGetDevicesFunctionFactory() {
-  return new FakeSerialGetDevicesFunction();
-}
-
 ExtensionFunction* FakeSerialConnectFunctionFactory() {
   return new FakeSerialConnectFunction();
 }
@@ -158,8 +167,6 @@ IN_PROC_BROWSER_TEST_F(SerialApiTest, SerialFakeHardware) {
   catcher.RestrictToBrowserContext(browser()->profile());
 
 #if SIMULATE_SERIAL_PORTS
-  ASSERT_TRUE(OverrideFunction("serial.getDevices",
-                               FakeSerialGetDevicesFunctionFactory));
   ASSERT_TRUE(
       OverrideFunction("serial.connect", FakeSerialConnectFunctionFactory));
 #endif
@@ -174,4 +181,17 @@ IN_PROC_BROWSER_TEST_F(SerialApiTest, SerialRealHardware) {
   ASSERT_TRUE(RunExtensionTest("serial/real_hardware")) << message_;
 }
 
+IN_PROC_BROWSER_TEST_F(SerialApiTest, SerialRealHardwareFail) {
+  // Intercept the request and then drop it, chrome.serial.getDevices() should
+  // get an empty list.
+  service_manager::ServiceContext::SetGlobalBinderForTesting(
+      device::mojom::kServiceName, device::mojom::SerialDeviceEnumerator::Name_,
+      base::Bind(&DropBindRequest));
+
+  ResultCatcher catcher;
+  catcher.RestrictToBrowserContext(browser()->profile());
+
+  ASSERT_TRUE(RunExtensionTest("serial/real_hardware_fail")) << message_;
+}
+
 }  // namespace extensions

services/device/BUILD.gn

@@ -11,6 +11,8 @@ if (is_android) {
   import("//build/config/android/rules.gni")
 }
 
+is_serial_enabled_platform = is_win || (is_linux && use_udev) || is_mac
+
 source_set("lib") {
   # This should be visible only to embedders of the Device Service, and the
   # dependence should only be for the purpose of embedding the Device Service.
@@ -51,6 +53,10 @@ source_set("lib") {
       "//services/device/vibration",
     ]
   }
+
+  if (is_serial_enabled_platform) {
+    deps += [ "//services/device/serial" ]
+  }
 }
 
 is_linux_without_udev = is_linux && !use_udev
@@ -119,6 +125,11 @@ source_set("tests") {
     ]
   }
 
+  if (is_serial_enabled_platform) {
+    sources += [ "serial/serial_device_enumerator_impl_unittest.cc" ]
+    deps += [ "//services/device/serial" ]
+  }
+
   if (is_win) {
     # Needed for "generic_sensor/platform_sensor_and_provider_unittest_win.cc"
     libs = [

services/device/device_service.cc

@@ -12,6 +12,7 @@
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "build/build_config.h"
 #include "device/sensors/device_sensor_host.h"
 #include "mojo/public/cpp/system/message_pipe.h"
 #include "services/device/fingerprint/fingerprint.h"
@@ -19,6 +20,7 @@
 #include "services/device/power_monitor/power_monitor_message_broadcaster.h"
 #include "services/device/public/cpp/device_features.h"
 #include "services/device/public/interfaces/battery_monitor.mojom.h"
+#include "services/device/serial/serial_device_enumerator_impl.h"
 #include "services/device/time_zone_monitor/time_zone_monitor.h"
 #include "services/device/wake_lock/wake_lock_provider.h"
 #include "ui/gfx/native_widget_types.h"
@@ -109,6 +111,9 @@ void DeviceService::OnStart() {
       &DeviceService::BindTimeZoneMonitorRequest, base::Unretained(this)));
   registry_.AddInterface<mojom::WakeLockProvider>(base::Bind(
       &DeviceService::BindWakeLockProviderRequest, base::Unretained(this)));
+  registry_.AddInterface<mojom::SerialDeviceEnumerator>(
+      base::Bind(&DeviceService::BindSerialDeviceEnumeratorRequest,
+                 base::Unretained(this)));
 
 #if defined(OS_ANDROID)
   registry_.AddInterface(GetJavaInterfaceProvider()
@@ -248,6 +253,14 @@ void DeviceService::BindWakeLockProviderRequest(
                            wake_lock_context_callback_);
 }
 
+void DeviceService::BindSerialDeviceEnumeratorRequest(
+    mojom::SerialDeviceEnumeratorRequest request) {
+#if (defined(OS_LINUX) && defined(USE_UDEV)) || defined(OS_WIN) || \
+    defined(OS_MACOSX)
+  SerialDeviceEnumeratorImpl::Create(std::move(request));
+#endif
+}
+
 #if defined(OS_ANDROID)
 service_manager::InterfaceProvider* DeviceService::GetJavaInterfaceProvider() {
   if (!java_interface_provider_initialized_) {

services/device/device_service.h

@@ -15,6 +15,7 @@
 #include "services/device/public/interfaces/nfc_provider.mojom.h"
 #include "services/device/public/interfaces/power_monitor.mojom.h"
 #include "services/device/public/interfaces/sensor_provider.mojom.h"
+#include "services/device/public/interfaces/serial.mojom.h"
 #include "services/device/public/interfaces/time_zone_monitor.mojom.h"
 #include "services/device/public/interfaces/vibration_manager.mojom.h"
 #include "services/device/public/interfaces/wake_lock_provider.mojom.h"
@@ -97,6 +98,9 @@ class DeviceService : public service_manager::Service {
 
   void BindWakeLockProviderRequest(mojom::WakeLockProviderRequest request);
 
+  void BindSerialDeviceEnumeratorRequest(
+      mojom::SerialDeviceEnumeratorRequest request);
+
   std::unique_ptr<PowerMonitorMessageBroadcaster>
       power_monitor_message_broadcaster_;
   std::unique_ptr<TimeZoneMonitor> time_zone_monitor_;

services/device/manifest.json

@@ -16,6 +16,7 @@
           "device::mojom::OrientationAbsoluteSensor",
           "device::mojom::OrientationSensor"
         ],
+        "device:serial": [ "device::mojom::SerialDeviceEnumerator" ],
         "device:time_zone_monitor": [ "device::mojom::TimeZoneMonitor" ],
         "device:vibration": [ "device::mojom::VibrationManager" ],
         "device:wake_lock": [ "device::mojom::WakeLockProvider" ]

services/device/public/interfaces/BUILD.gn

@@ -12,6 +12,7 @@ mojom("interfaces") {
     "nfc.mojom",
     "nfc_provider.mojom",
     "power_monitor.mojom",
+    "serial.mojom",
     "time_zone_monitor.mojom",
     "vibration_manager.mojom",
     "wake_lock.mojom",
@@ -23,6 +24,10 @@ mojom("interfaces") {
     ":constants",
   ]
 
+  deps = [
+    "//device/serial:serial_mojo",
+  ]
+
   # TODO(crbug.com/699569): Convert to use the new JS bindings.
   js_bindings_mode = "both"
 }

services/device/public/interfaces/serial.mojom

+// Copyright 2017 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.
+
+module device.mojom;
+
+import "device/serial/serial.mojom";
+
+// Discovers and enumerates serial devices available to the host.
+interface SerialDeviceEnumerator {
+  GetDevices() => (array<SerialDeviceInfo> devices);
+};

services/device/serial/BUILD.gn

+# Copyright 2017 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.
+
+import("//build/config/features.gni")
+
+if (is_win || (is_linux && use_udev) || is_mac) {
+  source_set("serial") {
+    visibility = [
+      "//services/device:lib",
+      "//services/device:tests",
+    ]
+
+    sources = [
+      "serial_device_enumerator_impl.cc",
+      "serial_device_enumerator_impl.h",
+    ]
+
+    public_deps = [
+      "//services/device/public/interfaces",
+    ]
+
+    deps = [
+      "//base",
+      "//device/serial",
+      "//mojo/public/cpp/bindings",
+    ]
+  }
+}

services/device/serial/DEPS

+include_rules = [
+  "+device/serial",
+]

services/device/serial/serial_device_enumerator_impl.cc

+// Copyright 2017 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 "services/device/serial/serial_device_enumerator_impl.h"
+
+#include "base/memory/ptr_util.h"
+#include "base/task_scheduler/post_task.h"
+#include "mojo/public/cpp/bindings/strong_binding.h"
+
+namespace device {
+
+namespace {
+
+void CreateAndBindOnBlockableRunner(
+    mojom::SerialDeviceEnumeratorRequest request) {
+  mojo::MakeStrongBinding(base::MakeUnique<SerialDeviceEnumeratorImpl>(),
+                          std::move(request));
+}
+
+}  // namespace
+
+// static
+void SerialDeviceEnumeratorImpl::Create(
+    mojom::SerialDeviceEnumeratorRequest request) {
+  // SerialDeviceEnumeratorImpl must live on a thread that is allowed to do
+  // blocking IO.
+  scoped_refptr<base::SequencedTaskRunner> blockable_sequence_runner =
+      base::CreateSequencedTaskRunnerWithTraits(
+          {base::MayBlock(), base::TaskPriority::BACKGROUND});
+  blockable_sequence_runner->PostTask(
+      FROM_HERE,
+      base::BindOnce(&CreateAndBindOnBlockableRunner, std::move(request)));
+}
+
+SerialDeviceEnumeratorImpl::SerialDeviceEnumeratorImpl()
+    : enumerator_(device::SerialDeviceEnumerator::Create()) {}
+
+SerialDeviceEnumeratorImpl::~SerialDeviceEnumeratorImpl() = default;
+
+void SerialDeviceEnumeratorImpl::GetDevices(GetDevicesCallback callback) {
+  DCHECK(enumerator_);
+  std::move(callback).Run(enumerator_->GetDevices());
+}
+
+}  // namespace device

services/device/serial/serial_device_enumerator_impl.h

+// Copyright 2017 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 SERVICES_DEVICE_SERIAL_SERIAL_DEVICE_ENUMERATOR_IMPL_H_
+#define SERVICES_DEVICE_SERIAL_SERIAL_DEVICE_ENUMERATOR_IMPL_H_
+
+#include <memory>
+
+#include "base/macros.h"
+#include "device/serial/serial_device_enumerator.h"
+#include "services/device/public/interfaces/serial.mojom.h"
+
+namespace device {
+
+// TODO(leonhsl): Merge this class with SerialDeviceEnumerator if/once
+// SerialDeviceEnumerator is exposed only via the Device Service.
+// crbug.com/748505
+class SerialDeviceEnumeratorImpl : public mojom::SerialDeviceEnumerator {
+ public:
+  static void Create(mojom::SerialDeviceEnumeratorRequest request);
+
+  SerialDeviceEnumeratorImpl();
+  ~SerialDeviceEnumeratorImpl() override;
+
+ private:
+  // mojom::SerialDeviceEnumerator methods:
+  void GetDevices(GetDevicesCallback callback) override;
+
+  std::unique_ptr<device::SerialDeviceEnumerator> enumerator_;
+
+  DISALLOW_COPY_AND_ASSIGN(SerialDeviceEnumeratorImpl);
+};
+
+}  // namespace device
+
+#endif  // SERVICES_DEVICE_SERIAL_SERIAL_DEVICE_ENUMERATOR_IMPL_H_

services/device/serial/serial_device_enumerator_impl_unittest.cc

+// Copyright (c) 2017 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 "services/device/serial/serial_device_enumerator_impl.h"
+
+#include "base/macros.h"
+#include "mojo/public/cpp/bindings/interface_ptr.h"
+#include "services/device/device_service_test_base.h"
+#include "services/device/public/interfaces/constants.mojom.h"
+#include "services/device/public/interfaces/serial.mojom.h"
+
+namespace device {
+
+namespace {
+
+class SerialDeviceEnumeratorImplTest : public DeviceServiceTestBase {
+ public:
+  SerialDeviceEnumeratorImplTest() = default;
+  ~SerialDeviceEnumeratorImplTest() override = default;
+
+ protected:
+  void SetUp() override {
+    DeviceServiceTestBase::SetUp();
+    connector()->BindInterface(mojom::kServiceName, &enumerator_);
+  }
+
+  void TearDown() override { enumerator_.reset(); }
+
+  mojom::SerialDeviceEnumeratorPtr enumerator_;
+
+  DISALLOW_COPY_AND_ASSIGN(SerialDeviceEnumeratorImplTest);
+};
+
+// This is to simply test that on Linux/Mac/Windows a client can connect to
+// Device Service and bind the serial SerialDeviceEnumerator interface
+// correctly.
+// TODO(leonhsl): figure out how to add more robust tests.
+TEST_F(SerialDeviceEnumeratorImplTest, SimpleConnectTest) {
+  enumerator_.FlushForTesting();
+}
+
+}  // namespace
+
+}  // namespace device