BASELINE: Update Chromium to 59.0.3071.134

Change-Id: Id02ef6fb2204c5fd21668a1c3e6911c83b17585a
Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>

28 files changed, 906 insertions, 60 deletions

diff --git a/chromium/services/device/BUILD.gn b/chromium/services/device/BUILD.gn
index 3783fed88bd..3f781a768a8 100644
--- a/chromium/services/device/BUILD.gn
+++ b/chromium/services/device/BUILD.gn
@@ -2,6 +2,8 @@
 # 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")
+import("//services/catalog/public/tools/catalog.gni")
 import("//services/service_manager/public/cpp/service.gni")
 import("//services/service_manager/public/service_manifest.gni")
 
@@ -10,6 +12,12 @@ if (is_android) {
 }
 
 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.
+  visibility = [
+    ":test_support",
+    "//content/browser",
+  ]
   sources = [
     "device_service.cc",
     "device_service.h",
@@ -17,10 +25,19 @@ source_set("lib") {
 
   deps = [
     "//base",
+    "//device/battery:mojo_bindings",
+    "//device/generic_sensor",
+    "//device/sensors",
+    "//device/sensors/public/interfaces",
+    "//device/vibration:mojo_bindings",
+    "//device/wake_lock",
     "//services/device/fingerprint",
     "//services/device/power_monitor",
+    "//services/device/public/cpp:device_features",
+    "//services/device/screen_orientation",
     "//services/device/time_zone_monitor",
     "//services/service_manager/public/cpp",
+    "//ui/gfx",
   ]
 
   if (is_android) {
@@ -28,6 +45,12 @@ source_set("lib") {
       "//services/device/android/register_jni.cc",
       "//services/device/android/register_jni.h",
     ]
+    deps += [ ":device_service_jni_headers" ]
+  } else {
+    deps += [
+      "//device/battery",
+      "//device/vibration",
+    ]
   }
 }
 
@@ -37,11 +60,14 @@ source_set("tests") {
   sources = [
     "power_monitor/power_monitor_message_broadcaster_unittest.cc",
     "public/cpp/power_monitor/power_monitor_broadcast_source_unittest.cc",
+    "vibration/vibration_manager_impl_unittest.cc",
   ]
 
   deps = [
+    ":test_support",
     "//base",
     "//base/test:test_support",
+    "//device/vibration:mojo_bindings",
     "//mojo/public/cpp/bindings",
     "//services/device/power_monitor",
     "//services/device/public/cpp/power_monitor",
@@ -52,6 +78,18 @@ source_set("tests") {
     sources += [ "fingerprint/fingerprint_chromeos_unittest.cc" ]
     deps += [ "//services/device/fingerprint" ]
   }
+
+  if (is_android) {
+    deps += [
+      ":device_service_jni_headers",
+      "//device/vibration/android:vibration_jni_headers",
+    ]
+  } else {
+    deps += [
+      "//device/battery",
+      "//device/vibration",
+    ]
+  }
 }
 
 service_manifest("manifest") {
@@ -59,11 +97,70 @@ service_manifest("manifest") {
   source = "manifest.json"
 }
 
+service_manifest("unittest_manifest") {
+  name = "device_unittests"
+  source = "unittest_manifest.json"
+  packaged_services = [ ":manifest" ]
+}
+
+catalog("tests_catalog") {
+  testonly = true
+  embedded_services = [ ":unittest_manifest" ]
+}
+
+source_set("test_support") {
+  testonly = true
+
+  sources = [
+    "device_service_test_base.cc",
+    "device_service_test_base.h",
+  ]
+
+  deps = [
+    ":lib",
+    "//base",
+    "//base/test:test_support",
+    "//mojo/public/cpp/bindings",
+    "//services/device/public/interfaces:constants",
+    "//services/service_manager/public/cpp:service_test_support",
+    "//services/service_manager/public/cpp:sources",
+  ]
+}
+
 if (is_android) {
+  generate_jni("device_service_jni_headers") {
+    sources = [
+      "android/java/src/org/chromium/services/device/InterfaceRegistrar.java",
+    ]
+    jni_package = "device_service"
+  }
+
   android_library("java") {
-    java_files = [ "time_zone_monitor/android/java/src/org/chromium/device/time_zone_monitor/TimeZoneMonitor.java" ]
+    # 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.
+    # //content/public/android:* here actually wants to identify the
+    # //content/public/android:content_java target and all of its generated
+    # targets which also need to see this target as well.
+    # //services:* identifies //services:service_unittests and all of its
+    # generated targets.
+    visibility = [
+      "//content/public/android:*",
+      "//services:*",
+    ]
+    java_files = [ "android/java/src/org/chromium/services/device/InterfaceRegistrar.java" ]
     deps = [
       "//base:base_java",
+      "//device/battery:mojo_bindings_java",
+      "//device/battery/android:battery_monitor_java",
+      "//device/vibration:mojo_bindings_java",
+      "//device/vibration/android:vibration_manager_java",
+      "//mojo/android:system_java",
+      "//mojo/public/java:bindings_java",
+      "//mojo/public/java:system_java",
+      "//services/device/screen_orientation:java",
+      "//services/device/time_zone_monitor:java",
+      "//services/service_manager/public/interfaces:interfaces_java",
+      "//services/service_manager/public/java:service_manager_java",
     ]
   }
 }
diff --git a/chromium/services/device/DEPS b/chromium/services/device/DEPS
index 56fffa1fea5..6383a3f26cd 100644
--- a/chromium/services/device/DEPS
+++ b/chromium/services/device/DEPS
@@ -1,3 +1,5 @@
 include_rules = [
   "+device",
+  "+jni",
+  "+ui/gfx/native_widget_types.h",
 ]
diff --git a/chromium/services/device/OWNERS b/chromium/services/device/OWNERS
index f4ee2fd74db..e3cd731321f 100644
--- a/chromium/services/device/OWNERS
+++ b/chromium/services/device/OWNERS
@@ -2,4 +2,4 @@ blundell@chromium.org
 reillyg@chromium.org
 rockot@chromium.org
 
-# COMPONENT: IO>USB
\ No newline at end of file
+# TEAM: device-dev@chromium.org
diff --git a/chromium/services/device/device_service.cc b/chromium/services/device/device_service.cc
index f51d5a922e3..5578cf57256 100644
--- a/chromium/services/device/device_service.cc
+++ b/chromium/services/device/device_service.cc
@@ -4,65 +4,261 @@
 
 #include "services/device/device_service.h"
 
+#include <utility>
+
 #include "base/bind.h"
+#include "base/feature_list.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
+#include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "device/battery/battery_monitor.mojom.h"
+#include "device/battery/battery_monitor_impl.h"
+#include "device/battery/battery_status_service.h"
+#include "device/generic_sensor/sensor_provider_impl.h"
+#include "device/sensors/device_sensor_host.h"
+#include "device/wake_lock/wake_lock_context_provider.h"
+#include "mojo/public/cpp/system/message_pipe.h"
 #include "services/device/fingerprint/fingerprint.h"
 #include "services/device/power_monitor/power_monitor_message_broadcaster.h"
+#include "services/device/public/cpp/device_features.h"
 #include "services/device/time_zone_monitor/time_zone_monitor.h"
-#include "services/service_manager/public/cpp/connection.h"
 #include "services/service_manager/public/cpp/interface_registry.h"
+#include "services/service_manager/public/cpp/service_info.h"
+#include "ui/gfx/native_widget_types.h"
 
 #if defined(OS_ANDROID)
+#include "base/android/context_utils.h"
+#include "base/android/jni_android.h"
+#include "jni/InterfaceRegistrar_jni.h"
 #include "services/device/android/register_jni.h"
+#include "services/device/screen_orientation/screen_orientation_listener_android.h"
+#else
+#include "device/vibration/vibration_manager_impl.h"
 #endif
 
 namespace device {
 
-std::unique_ptr<service_manager::Service> CreateDeviceService(
-    scoped_refptr<base::SingleThreadTaskRunner> file_task_runner) {
 #if defined(OS_ANDROID)
+std::unique_ptr<service_manager::Service> CreateDeviceService(
+    scoped_refptr<base::SingleThreadTaskRunner> file_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
+    const WakeLockContextCallback& wake_lock_context_callback) {
   if (!EnsureJniRegistered()) {
     DLOG(ERROR) << "Failed to register JNI for Device Service";
     return nullptr;
   }
-#endif
 
-  return base::MakeUnique<DeviceService>(std::move(file_task_runner));
+  return base::MakeUnique<DeviceService>(std::move(file_task_runner),
+                                         std::move(io_task_runner),
+                                         wake_lock_context_callback);
 }
+#else
+std::unique_ptr<service_manager::Service> CreateDeviceService(
+    scoped_refptr<base::SingleThreadTaskRunner> file_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner) {
+  return base::MakeUnique<DeviceService>(std::move(file_task_runner),
+                                         std::move(io_task_runner));
+}
+#endif
 
+#if defined(OS_ANDROID)
+DeviceService::DeviceService(
+    scoped_refptr<base::SingleThreadTaskRunner> file_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
+    const WakeLockContextCallback& wake_lock_context_callback)
+    : java_interface_provider_initialized_(false),
+      file_task_runner_(std::move(file_task_runner)),
+      io_task_runner_(std::move(io_task_runner)),
+      wake_lock_context_callback_(wake_lock_context_callback) {}
+#else
 DeviceService::DeviceService(
-    scoped_refptr<base::SingleThreadTaskRunner> file_task_runner)
-    : file_task_runner_(std::move(file_task_runner)) {}
+    scoped_refptr<base::SingleThreadTaskRunner> file_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner)
+    : file_task_runner_(std::move(file_task_runner)),
+      io_task_runner_(std::move(io_task_runner)) {}
+#endif
+
+DeviceService::~DeviceService() {
+#if !defined(OS_ANDROID)
+  device::BatteryStatusService::GetInstance()->Shutdown();
+#endif
+}
 
-DeviceService::~DeviceService() {}
+void DeviceService::OnStart() {
+  registry_.AddInterface<mojom::Fingerprint>(this);
+  registry_.AddInterface<mojom::LightSensor>(this);
+  registry_.AddInterface<mojom::MotionSensor>(this);
+  registry_.AddInterface<mojom::OrientationSensor>(this);
+  registry_.AddInterface<mojom::OrientationAbsoluteSensor>(this);
+  registry_.AddInterface<mojom::PowerMonitor>(this);
+  registry_.AddInterface<mojom::ScreenOrientationListener>(this);
+  if (base::FeatureList::IsEnabled(features::kGenericSensor)) {
+    registry_.AddInterface<mojom::SensorProvider>(this);
+  }
+  registry_.AddInterface<mojom::TimeZoneMonitor>(this);
+  registry_.AddInterface<mojom::WakeLockContextProvider>(this);
 
-void DeviceService::OnStart() {}
+#if defined(OS_ANDROID)
+  registry_.AddInterface(GetJavaInterfaceProvider()
+                             ->CreateInterfaceFactory<mojom::BatteryMonitor>());
+  registry_.AddInterface(
+      GetJavaInterfaceProvider()
+          ->CreateInterfaceFactory<mojom::VibrationManager>());
+#else
+  registry_.AddInterface<mojom::BatteryMonitor>(this);
+  registry_.AddInterface<mojom::VibrationManager>(this);
+#endif
+}
 
-bool DeviceService::OnConnect(const service_manager::ServiceInfo& remote_info,
-                              service_manager::InterfaceRegistry* registry) {
-  registry->AddInterface<mojom::Fingerprint>(this);
-  registry->AddInterface<mojom::PowerMonitor>(this);
-  registry->AddInterface<mojom::TimeZoneMonitor>(this);
-  return true;
+void DeviceService::OnBindInterface(
+    const service_manager::ServiceInfo& source_info,
+    const std::string& interface_name,
+    mojo::ScopedMessagePipeHandle interface_pipe) {
+  registry_.BindInterface(source_info.identity, interface_name,
+                          std::move(interface_pipe));
 }
 
+#if !defined(OS_ANDROID)
+void DeviceService::Create(const service_manager::Identity& remote_identity,
+                           mojom::BatteryMonitorRequest request) {
+  BatteryMonitorImpl::Create(std::move(request));
+}
+
+void DeviceService::Create(const service_manager::Identity& remote_identity,
+                           mojom::VibrationManagerRequest request) {
+  VibrationManagerImpl::Create(std::move(request));
+}
+#endif
+
 void DeviceService::Create(const service_manager::Identity& remote_identity,
                            mojom::FingerprintRequest request) {
   Fingerprint::Create(std::move(request));
 }
 
 void DeviceService::Create(const service_manager::Identity& remote_identity,
+                           mojom::LightSensorRequest request) {
+#if defined(OS_ANDROID)
+  // On Android the device sensors implementations need to run on the UI thread
+  // to communicate to Java.
+  DeviceLightHost::Create(std::move(request));
+#else
+  // On platforms other than Android the device sensors implementations run on
+  // the IO thread.
+  if (io_task_runner_) {
+    io_task_runner_->PostTask(FROM_HERE, base::Bind(&DeviceLightHost::Create,
+                                                    base::Passed(&request)));
+  }
+#endif  // defined(OS_ANDROID)
+}
+
+void DeviceService::Create(const service_manager::Identity& remote_identity,
+                           mojom::MotionSensorRequest request) {
+#if defined(OS_ANDROID)
+  // On Android the device sensors implementations need to run on the UI thread
+  // to communicate to Java.
+  DeviceMotionHost::Create(std::move(request));
+#else
+  // On platforms other than Android the device sensors implementations run on
+  // the IO thread.
+  if (io_task_runner_) {
+    io_task_runner_->PostTask(FROM_HERE, base::Bind(&DeviceMotionHost::Create,
+                                                    base::Passed(&request)));
+  }
+#endif  // defined(OS_ANDROID)
+}
+
+void DeviceService::Create(const service_manager::Identity& remote_identity,
+                           mojom::OrientationSensorRequest request) {
+#if defined(OS_ANDROID)
+  // On Android the device sensors implementations need to run on the UI thread
+  // to communicate to Java.
+  DeviceOrientationHost::Create(std::move(request));
+#else
+  // On platforms other than Android the device sensors implementations run on
+  // the IO thread.
+  if (io_task_runner_) {
+    io_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&DeviceOrientationHost::Create, base::Passed(&request)));
+  }
+#endif  // defined(OS_ANDROID)
+}
+
+void DeviceService::Create(const service_manager::Identity& remote_identity,
+                           mojom::OrientationAbsoluteSensorRequest request) {
+#if defined(OS_ANDROID)
+  // On Android the device sensors implementations need to run on the UI thread
+  // to communicate to Java.
+  DeviceOrientationAbsoluteHost::Create(std::move(request));
+#else
+  // On platforms other than Android the device sensors implementations run on
+  // the IO thread.
+  if (io_task_runner_) {
+    io_task_runner_->PostTask(FROM_HERE,
+                              base::Bind(&DeviceOrientationAbsoluteHost::Create,
+                                         base::Passed(&request)));
+  }
+#endif  // defined(OS_ANDROID)
+}
+
+void DeviceService::Create(const service_manager::Identity& remote_identity,
                            mojom::PowerMonitorRequest request) {
-  PowerMonitorMessageBroadcaster::Create(std::move(request));
+  if (!power_monitor_message_broadcaster_) {
+    power_monitor_message_broadcaster_ =
+        base::MakeUnique<PowerMonitorMessageBroadcaster>();
+  }
+  power_monitor_message_broadcaster_->Bind(std::move(request));
+}
+
+void DeviceService::Create(const service_manager::Identity& remote_identity,
+                           mojom::ScreenOrientationListenerRequest request) {
+#if defined(OS_ANDROID)
+  if (io_task_runner_) {
+    io_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&ScreenOrientationListenerAndroid::Create,
+                              base::Passed(&request)));
+  }
+#endif
+}
+
+void DeviceService::Create(const service_manager::Identity& remote_identity,
+                           mojom::SensorProviderRequest request) {
+  if (io_task_runner_) {
+    io_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&device::SensorProviderImpl::Create,
+                              file_task_runner_, base::Passed(&request)));
+  }
 }
 
 void DeviceService::Create(const service_manager::Identity& remote_identity,
                            mojom::TimeZoneMonitorRequest request) {
   if (!time_zone_monitor_)
-    time_zone_monitor_ = device::TimeZoneMonitor::Create(file_task_runner_);
+    time_zone_monitor_ = TimeZoneMonitor::Create(file_task_runner_);
   time_zone_monitor_->Bind(std::move(request));
 }
 
+void DeviceService::Create(const service_manager::Identity& remote_identity,
+                           mojom::WakeLockContextProviderRequest request) {
+  WakeLockContextProvider::Create(std::move(request), file_task_runner_,
+                                  wake_lock_context_callback_);
+}
+
+#if defined(OS_ANDROID)
+service_manager::InterfaceProvider* DeviceService::GetJavaInterfaceProvider() {
+  if (!java_interface_provider_initialized_) {
+    service_manager::mojom::InterfaceProviderPtr provider;
+    JNIEnv* env = base::android::AttachCurrentThread();
+    Java_InterfaceRegistrar_createInterfaceRegistryForContext(
+        env, mojo::MakeRequest(&provider).PassMessagePipe().release().value(),
+        base::android::GetApplicationContext());
+    java_interface_provider_.Bind(std::move(provider));
+
+    java_interface_provider_initialized_ = true;
+  }
+
+  return &java_interface_provider_;
+}
+#endif
+
 }  // namespace device
diff --git a/chromium/services/device/device_service.h b/chromium/services/device/device_service.h
index 630b928af7b..cd38c236003 100644
--- a/chromium/services/device/device_service.h
+++ b/chromium/services/device/device_service.h
@@ -6,50 +6,151 @@
 #define SERVICES_DEVICE_DEVICE_SERVICE_H_
 
 #include "base/memory/ref_counted.h"
+#include "device/battery/battery_monitor.mojom.h"
+#include "device/generic_sensor/public/interfaces/sensor_provider.mojom.h"
+#include "device/screen_orientation/public/interfaces/screen_orientation.mojom.h"
+#include "device/sensors/public/interfaces/light.mojom.h"
+#include "device/sensors/public/interfaces/motion.mojom.h"
+#include "device/sensors/public/interfaces/orientation.mojom.h"
+#include "device/vibration/vibration_manager.mojom.h"
+#include "device/wake_lock/public/interfaces/wake_lock_context_provider.mojom.h"
+#include "device/wake_lock/wake_lock_service_context.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 #include "services/device/public/interfaces/fingerprint.mojom.h"
 #include "services/device/public/interfaces/power_monitor.mojom.h"
 #include "services/device/public/interfaces/time_zone_monitor.mojom.h"
+#include "services/service_manager/public/cpp/binder_registry.h"
 #include "services/service_manager/public/cpp/interface_factory.h"
+#include "services/service_manager/public/cpp/interface_provider.h"
 #include "services/service_manager/public/cpp/service.h"
 
+namespace base {
+class SingleThreadTaskRunner;
+}
+
 namespace device {
 
+class PowerMonitorMessageBroadcaster;
 class TimeZoneMonitor;
 
+#if defined(OS_ANDROID)
+std::unique_ptr<service_manager::Service> CreateDeviceService(
+    scoped_refptr<base::SingleThreadTaskRunner> file_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
+    const WakeLockContextCallback& wake_lock_context_callback);
+#else
 std::unique_ptr<service_manager::Service> CreateDeviceService(
-    scoped_refptr<base::SingleThreadTaskRunner> file_task_runner);
+    scoped_refptr<base::SingleThreadTaskRunner> file_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner);
+#endif
 
 class DeviceService
     : public service_manager::Service,
       public service_manager::InterfaceFactory<mojom::Fingerprint>,
+      public service_manager::InterfaceFactory<mojom::LightSensor>,
+      public service_manager::InterfaceFactory<mojom::MotionSensor>,
+      public service_manager::InterfaceFactory<mojom::OrientationSensor>,
+      public service_manager::InterfaceFactory<
+          mojom::OrientationAbsoluteSensor>,
+#if !defined(OS_ANDROID)
+      // On Android the Device Service provides BatteryMonitor via Java.
+      public service_manager::InterfaceFactory<mojom::BatteryMonitor>,
+      // On Android the Device Service provides VibrationManager via Java.
+      public service_manager::InterfaceFactory<mojom::VibrationManager>,
+#endif
       public service_manager::InterfaceFactory<mojom::PowerMonitor>,
-      public service_manager::InterfaceFactory<mojom::TimeZoneMonitor> {
+      public service_manager::InterfaceFactory<
+          mojom::ScreenOrientationListener>,
+      public service_manager::InterfaceFactory<mojom::SensorProvider>,
+      public service_manager::InterfaceFactory<mojom::TimeZoneMonitor>,
+      public service_manager::InterfaceFactory<mojom::WakeLockContextProvider> {
  public:
-  DeviceService(scoped_refptr<base::SingleThreadTaskRunner> file_task_runner);
+#if defined(OS_ANDROID)
+  DeviceService(scoped_refptr<base::SingleThreadTaskRunner> file_task_runner,
+                scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
+                const WakeLockContextCallback& wake_lock_context_callback);
+#else
+  DeviceService(scoped_refptr<base::SingleThreadTaskRunner> file_task_runner,
+                scoped_refptr<base::SingleThreadTaskRunner> io_task_runner);
+#endif
   ~DeviceService() override;
 
  private:
   // service_manager::Service:
   void OnStart() override;
-  bool OnConnect(const service_manager::ServiceInfo& remote_info,
-                 service_manager::InterfaceRegistry* registry) override;
+  void OnBindInterface(const service_manager::ServiceInfo& source_info,
+                       const std::string& interface_name,
+                       mojo::ScopedMessagePipeHandle interface_pipe) override;
 
   // InterfaceFactory<mojom::Fingerprint>:
   void Create(const service_manager::Identity& remote_identity,
               mojom::FingerprintRequest request) override;
 
+  // InterfaceFactory<mojom::LightSensor>:
+  void Create(const service_manager::Identity& remote_identity,
+              mojom::LightSensorRequest request) override;
+
+  // InterfaceFactory<mojom::MotionSensor>:
+  void Create(const service_manager::Identity& remote_identity,
+              mojom::MotionSensorRequest request) override;
+
+  // InterfaceFactory<mojom::OrientationSensor>:
+  void Create(const service_manager::Identity& remote_identity,
+              mojom::OrientationSensorRequest request) override;
+
+  // InterfaceFactory<mojom::OrientationAbsolueSensor>:
+  void Create(const service_manager::Identity& remote_identity,
+              mojom::OrientationAbsoluteSensorRequest request) override;
+
+#if !defined(OS_ANDROID)
+  // InterfaceFactory<mojom::BatteryMonitor>:
+  void Create(const service_manager::Identity& remote_identity,
+              mojom::BatteryMonitorRequest request) override;
+  // InterfaceFactory<mojom::VibrationManager>:
+  void Create(const service_manager::Identity& remote_identity,
+              mojom::VibrationManagerRequest request) override;
+#endif
+
   // InterfaceFactory<mojom::PowerMonitor>:
   void Create(const service_manager::Identity& remote_identity,
               mojom::PowerMonitorRequest request) override;
 
+  // InterfaceFactory<mojom::ScreenOrientationListener>:
+  void Create(const service_manager::Identity& remote_identity,
+              mojom::ScreenOrientationListenerRequest request) override;
+
+  // InterfaceFactory<mojom::SensorProvider>:
+  void Create(const service_manager::Identity& remote_identity,
+              mojom::SensorProviderRequest request) override;
+
   // InterfaceFactory<mojom::TimeZoneMonitor>:
   void Create(const service_manager::Identity& remote_identity,
               mojom::TimeZoneMonitorRequest request) override;
 
-  std::unique_ptr<device::TimeZoneMonitor> time_zone_monitor_;
+  // InterfaceFactory<mojom::WakeLockContextProvider>:
+  void Create(const service_manager::Identity& remote_identity,
+              mojom::WakeLockContextProviderRequest request) override;
+
+  std::unique_ptr<PowerMonitorMessageBroadcaster>
+      power_monitor_message_broadcaster_;
+  std::unique_ptr<TimeZoneMonitor> time_zone_monitor_;
+#if defined(OS_ANDROID)
+  // Binds |java_interface_provider_| to an interface registry that exposes
+  // factories for the interfaces that are provided via Java on Android.
+  service_manager::InterfaceProvider* GetJavaInterfaceProvider();
+
+  // InterfaceProvider that is bound to the Java-side interface registry.
+  service_manager::InterfaceProvider java_interface_provider_;
+
+  bool java_interface_provider_initialized_;
+#endif
 
   scoped_refptr<base::SingleThreadTaskRunner> file_task_runner_;
+  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
+
+  WakeLockContextCallback wake_lock_context_callback_;
+
+  service_manager::BinderRegistry registry_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceService);
 };
diff --git a/chromium/services/device/device_service_test_base.cc b/chromium/services/device/device_service_test_base.cc
new file mode 100644
index 00000000000..595f669d9ce
--- /dev/null
+++ b/chromium/services/device/device_service_test_base.cc
@@ -0,0 +1,95 @@
+// 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/device_service_test_base.h"
+
+#include <memory>
+
+#include "base/memory/ptr_util.h"
+#include "base/threading/thread.h"
+#include "mojo/public/cpp/bindings/binding_set.h"
+#include "services/device/device_service.h"
+#include "services/device/public/interfaces/constants.mojom.h"
+#include "services/service_manager/public/cpp/binder_registry.h"
+#include "services/service_manager/public/cpp/interface_factory.h"
+#include "services/service_manager/public/cpp/service_context.h"
+#include "services/service_manager/public/interfaces/service_factory.mojom.h"
+
+namespace device {
+
+namespace {
+
+const char kTestServiceName[] = "device_unittests";
+
+// The test service responsible to package Device Service.
+class ServiceTestClient : public service_manager::test::ServiceTestClient,
+                          public service_manager::mojom::ServiceFactory,
+                          public service_manager::InterfaceFactory<
+                              service_manager::mojom::ServiceFactory> {
+ public:
+  explicit ServiceTestClient(service_manager::test::ServiceTest* test)
+      : service_manager::test::ServiceTestClient(test),
+        io_thread_("DeviceServiceTestIOThread"),
+        file_thread_("DeviceServiceTestFileThread") {
+    registry_.AddInterface<service_manager::mojom::ServiceFactory>(this);
+  }
+  ~ServiceTestClient() override {}
+
+ protected:
+  void OnBindInterface(const service_manager::ServiceInfo& source_info,
+                       const std::string& interface_name,
+                       mojo::ScopedMessagePipeHandle interface_pipe) override {
+    registry_.BindInterface(source_info.identity, interface_name,
+                            std::move(interface_pipe));
+  }
+
+  void CreateService(service_manager::mojom::ServiceRequest request,
+                     const std::string& name) override {
+    if (name == device::mojom::kServiceName) {
+      io_thread_.Start();
+      file_thread_.Start();
+#if defined(OS_ANDROID)
+      device_service_context_.reset(new service_manager::ServiceContext(
+          CreateDeviceService(file_thread_.task_runner(),
+                              io_thread_.task_runner(),
+                              wake_lock_context_callback_),
+          std::move(request)));
+#else
+      device_service_context_.reset(new service_manager::ServiceContext(
+          CreateDeviceService(file_thread_.task_runner(),
+                              io_thread_.task_runner()),
+          std::move(request)));
+#endif
+    }
+  }
+
+  void Create(const service_manager::Identity& remote_identity,
+              service_manager::mojom::ServiceFactoryRequest request) override {
+    service_factory_bindings_.AddBinding(this, std::move(request));
+  }
+
+ private:
+  base::Thread io_thread_;
+  base::Thread file_thread_;
+  service_manager::BinderRegistry registry_;
+  mojo::BindingSet<service_manager::mojom::ServiceFactory>
+      service_factory_bindings_;
+  std::unique_ptr<service_manager::ServiceContext> device_service_context_;
+
+  WakeLockContextCallback wake_lock_context_callback_;
+};
+
+}  // namespace
+
+DeviceServiceTestBase::DeviceServiceTestBase()
+    : ServiceTest(kTestServiceName) {}
+
+DeviceServiceTestBase::~DeviceServiceTestBase() {}
+
+std::unique_ptr<service_manager::Service>
+DeviceServiceTestBase::CreateService() {
+  return base::MakeUnique<ServiceTestClient>(this);
+}
+
+}  // namespace device
diff --git a/chromium/services/device/device_service_test_base.h b/chromium/services/device/device_service_test_base.h
new file mode 100644
index 00000000000..4df7d1ea454
--- /dev/null
+++ b/chromium/services/device/device_service_test_base.h
@@ -0,0 +1,28 @@
+// 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_DEVICE_SERVICE_TEST_BASE_H_
+#define SERVICES_DEVICE_DEVICE_SERVICE_TEST_BASE_H_
+
+#include "base/macros.h"
+#include "services/service_manager/public/cpp/service_test.h"
+
+namespace device {
+
+// Base class responsible to setup Device Service for test.
+class DeviceServiceTestBase : public service_manager::test::ServiceTest {
+ public:
+  DeviceServiceTestBase();
+  ~DeviceServiceTestBase() override;
+
+ private:
+  // service_manager::test::ServiceTest:
+  std::unique_ptr<service_manager::Service> CreateService() override;
+
+  DISALLOW_COPY_AND_ASSIGN(DeviceServiceTestBase);
+};
+
+}  // namespace device
+
+#endif  // SERVICES_DEVICE_DEVICE_SERVICE_TEST_BASE_H_
diff --git a/chromium/services/device/manifest.json b/chromium/services/device/manifest.json
index 0ec13e56105..6b7a1b0ddfd 100644
--- a/chromium/services/device/manifest.json
+++ b/chromium/services/device/manifest.json
@@ -4,9 +4,20 @@
   "interface_provider_specs": {
     "service_manager:connector": {
       "provides": {
+        "device:battery_monitor": [ "device::mojom::BatteryMonitor" ],
+        "device:fingerprint": [ "device::mojom::Fingerprint" ],
+        "device:generic_sensor": [ "device::mojom::SensorProvider" ],
         "device:power_monitor": [ "device::mojom::PowerMonitor" ],
+        "device:screen_orientation": [ "device::mojom::ScreenOrientationListener" ],
+        "device:sensors": [
+          "device::mojom::LightSensor",
+          "device::mojom::MotionSensor",
+          "device::mojom::OrientationAbsoluteSensor",
+          "device::mojom::OrientationSensor"
+        ],
         "device:time_zone_monitor": [ "device::mojom::TimeZoneMonitor" ],
-	"device:fingerprint": [ "device::mojom::Fingerprint" ]
+        "device:vibration": [ "device::mojom::VibrationManager" ],
+        "device:wake_lock": [ "device::mojom::WakeLockContextProvider" ]
       },
       "requires": {
         "service_manager": [ "service_manager:all_users" ]
diff --git a/chromium/services/device/power_monitor/OWNERS b/chromium/services/device/power_monitor/OWNERS
index 92c60edbe66..887a99be3cb 100644
--- a/chromium/services/device/power_monitor/OWNERS
+++ b/chromium/services/device/power_monitor/OWNERS
@@ -1,4 +1,2 @@
 bajones@chromium.org
 blundell@chromium.org
-
-# COMPONENT: Manifest
diff --git a/chromium/services/device/power_monitor/power_monitor_message_broadcaster.cc b/chromium/services/device/power_monitor/power_monitor_message_broadcaster.cc
index 8361caea812..efc26420c8b 100644
--- a/chromium/services/device/power_monitor/power_monitor_message_broadcaster.cc
+++ b/chromium/services/device/power_monitor/power_monitor_message_broadcaster.cc
@@ -23,37 +23,35 @@ PowerMonitorMessageBroadcaster::~PowerMonitorMessageBroadcaster() {
 }
 
 // static
-void PowerMonitorMessageBroadcaster::Create(
+void PowerMonitorMessageBroadcaster::Bind(
     device::mojom::PowerMonitorRequest request) {
-  mojo::MakeStrongBinding(base::MakeUnique<PowerMonitorMessageBroadcaster>(),
-                          std::move(request));
+  bindings_.AddBinding(this, std::move(request));
 }
 
-void PowerMonitorMessageBroadcaster::SetClient(
+void PowerMonitorMessageBroadcaster::AddClient(
     device::mojom::PowerMonitorClientPtr power_monitor_client) {
-  power_monitor_client_ = std::move(power_monitor_client);
+  clients_.AddPtr(std::move(power_monitor_client));
   base::PowerMonitor* power_monitor = base::PowerMonitor::Get();
   // Unit tests does not initialize the PowerMonitor.
-  if (power_monitor)
+  if (power_monitor) {
     OnPowerStateChange(power_monitor->IsOnBatteryPower());
+  }
 }
 
 void PowerMonitorMessageBroadcaster::OnPowerStateChange(bool on_battery_power) {
-  if (power_monitor_client_) {
-    power_monitor_client_->PowerStateChange(on_battery_power);
-  }
+  clients_.ForAllPtrs([&on_battery_power](mojom::PowerMonitorClient* client) {
+    client->PowerStateChange(on_battery_power);
+  });
 }
 
 void PowerMonitorMessageBroadcaster::OnSuspend() {
-  if (power_monitor_client_) {
-    power_monitor_client_->Suspend();
-  }
+  clients_.ForAllPtrs(
+      [](mojom::PowerMonitorClient* client) { client->Suspend(); });
 }
 
 void PowerMonitorMessageBroadcaster::OnResume() {
-  if (power_monitor_client_) {
-    power_monitor_client_->Resume();
-  }
+  clients_.ForAllPtrs(
+      [](mojom::PowerMonitorClient* client) { client->Resume(); });
 }
 
 }  // namespace device
diff --git a/chromium/services/device/power_monitor/power_monitor_message_broadcaster.h b/chromium/services/device/power_monitor/power_monitor_message_broadcaster.h
index 41ea658e2ee..0b42dfe1b3c 100644
--- a/chromium/services/device/power_monitor/power_monitor_message_broadcaster.h
+++ b/chromium/services/device/power_monitor/power_monitor_message_broadcaster.h
@@ -7,6 +7,8 @@
 
 #include "base/macros.h"
 #include "base/power_monitor/power_observer.h"
+#include "mojo/public/cpp/bindings/binding_set.h"
+#include "mojo/public/cpp/bindings/interface_ptr_set.h"
 #include "services/device/public/interfaces/power_monitor.mojom.h"
 
 namespace device {
@@ -16,13 +18,13 @@ namespace device {
 class PowerMonitorMessageBroadcaster : public base::PowerObserver,
                                        public device::mojom::PowerMonitor {
  public:
-  explicit PowerMonitorMessageBroadcaster();
+  PowerMonitorMessageBroadcaster();
   ~PowerMonitorMessageBroadcaster() override;
 
-  static void Create(device::mojom::PowerMonitorRequest request);
+  void Bind(device::mojom::PowerMonitorRequest request);
 
   // device::mojom::PowerMonitor:
-  void SetClient(
+  void AddClient(
       device::mojom::PowerMonitorClientPtr power_monitor_client) override;
 
   // base::PowerObserver:
@@ -31,7 +33,8 @@ class PowerMonitorMessageBroadcaster : public base::PowerObserver,
   void OnResume() override;
 
  private:
-  device::mojom::PowerMonitorClientPtr power_monitor_client_;
+  mojo::BindingSet<device::mojom::PowerMonitor> bindings_;
+  mojo::InterfacePtrSet<device::mojom::PowerMonitorClient> clients_;
 
   DISALLOW_COPY_AND_ASSIGN(PowerMonitorMessageBroadcaster);
 };
diff --git a/chromium/services/device/power_monitor/power_monitor_message_broadcaster_unittest.cc b/chromium/services/device/power_monitor/power_monitor_message_broadcaster_unittest.cc
index bde8cc3bc41..fddd208c4e7 100644
--- a/chromium/services/device/power_monitor/power_monitor_message_broadcaster_unittest.cc
+++ b/chromium/services/device/power_monitor/power_monitor_message_broadcaster_unittest.cc
@@ -66,8 +66,8 @@ TEST_F(PowerMonitorMessageBroadcasterTest, PowerMessageBroadcast) {
   FakePowerMonitorClient client(mojo::MakeRequest(&proxy));
   PowerMonitorMessageBroadcaster broadcaster;
 
-  // Calling SetClient should invoke a power state change.
-  broadcaster.SetClient(std::move(proxy));
+  // Calling AddClient should invoke a power state change.
+  broadcaster.AddClient(std::move(proxy));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(client.power_state_changes(), 1);
diff --git a/chromium/services/device/public/cpp/BUILD.gn b/chromium/services/device/public/cpp/BUILD.gn
new file mode 100644
index 00000000000..e9ebe278f99
--- /dev/null
+++ b/chromium/services/device/public/cpp/BUILD.gn
@@ -0,0 +1,17 @@
+# 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")
+
+source_set("device_features") {
+  public = [
+    "device_features.h",
+  ]
+  sources = [
+    "device_features.cc",
+  ]
+  public_deps = [
+    "//base",
+  ]
+}
diff --git a/chromium/services/device/public/cpp/device_features.cc b/chromium/services/device/public/cpp/device_features.cc
new file mode 100644
index 00000000000..ab4b9baa430
--- /dev/null
+++ b/chromium/services/device/public/cpp/device_features.cc
@@ -0,0 +1,14 @@
+// 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/public/cpp/device_features.h"
+
+namespace features {
+
+// Enables sensors based on Generic Sensor API:
+// https://w3c.github.io/sensors/
+const base::Feature kGenericSensor{"GenericSensor",
+                                   base::FEATURE_DISABLED_BY_DEFAULT};
+
+}  // namespace features
diff --git a/chromium/services/device/public/cpp/device_features.h b/chromium/services/device/public/cpp/device_features.h
new file mode 100644
index 00000000000..b10a16b6f0c
--- /dev/null
+++ b/chromium/services/device/public/cpp/device_features.h
@@ -0,0 +1,21 @@
+// 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.
+
+// This file defines all the public base::FeatureList features for the
+// services/device module.
+
+#ifndef SERVICES_DEVICE_PUBLIC_CPP_DEVICE_FEATURES_H_
+#define SERVICES_DEVICE_PUBLIC_CPP_DEVICE_FEATURES_H_
+
+#include "base/feature_list.h"
+
+namespace features {
+
+// The features should be documented alongside the definition of their values
+// in the .cc file.
+extern const base::Feature kGenericSensor;
+
+}  // namespace features
+
+#endif  // SERVICES_DEVICE_PUBLIC_CPP_DEVICE_FEATURES_H_
diff --git a/chromium/services/device/public/cpp/power_monitor/OWNERS b/chromium/services/device/public/cpp/power_monitor/OWNERS
index 92c60edbe66..887a99be3cb 100644
--- a/chromium/services/device/public/cpp/power_monitor/OWNERS
+++ b/chromium/services/device/public/cpp/power_monitor/OWNERS
@@ -1,4 +1,2 @@
 bajones@chromium.org
 blundell@chromium.org
-
-# COMPONENT: Manifest
diff --git a/chromium/services/device/public/cpp/power_monitor/power_monitor_broadcast_source.cc b/chromium/services/device/public/cpp/power_monitor/power_monitor_broadcast_source.cc
index d2b06d506f7..e3253556b39 100644
--- a/chromium/services/device/public/cpp/power_monitor/power_monitor_broadcast_source.cc
+++ b/chromium/services/device/public/cpp/power_monitor/power_monitor_broadcast_source.cc
@@ -7,16 +7,19 @@
 #include "base/location.h"
 #include "base/macros.h"
 #include "mojo/public/cpp/bindings/binding.h"
+#include "services/device/public/interfaces/constants.mojom.h"
+#include "services/service_manager/public/cpp/connector.h"
 
 namespace device {
 
 PowerMonitorBroadcastSource::PowerMonitorBroadcastSource(
-    service_manager::InterfaceProvider* interface_provider)
+    service_manager::Connector* connector)
     : last_reported_battery_power_state_(false), binding_(this) {
-  if (interface_provider) {
+  if (connector) {
     device::mojom::PowerMonitorPtr power_monitor;
-    interface_provider->GetInterface(mojo::MakeRequest(&power_monitor));
-    power_monitor->SetClient(binding_.CreateInterfacePtrAndBind());
+    connector->BindInterface(device::mojom::kServiceName,
+                             mojo::MakeRequest(&power_monitor));
+    power_monitor->AddClient(binding_.CreateInterfacePtrAndBind());
   }
 }
 
diff --git a/chromium/services/device/public/cpp/power_monitor/power_monitor_broadcast_source.h b/chromium/services/device/public/cpp/power_monitor/power_monitor_broadcast_source.h
index 5f8f06ec379..1969aff114d 100644
--- a/chromium/services/device/public/cpp/power_monitor/power_monitor_broadcast_source.h
+++ b/chromium/services/device/public/cpp/power_monitor/power_monitor_broadcast_source.h
@@ -9,7 +9,10 @@
 #include "base/power_monitor/power_monitor_source.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "services/device/public/interfaces/power_monitor.mojom.h"
-#include "services/service_manager/public/cpp/interface_provider.h"
+
+namespace service_manager {
+class Connector;
+}
 
 namespace device {
 
@@ -18,8 +21,7 @@ namespace device {
 class PowerMonitorBroadcastSource : public base::PowerMonitorSource,
                                     public device::mojom::PowerMonitorClient {
  public:
-  explicit PowerMonitorBroadcastSource(
-      service_manager::InterfaceProvider* interface_provider);
+  explicit PowerMonitorBroadcastSource(service_manager::Connector* connector);
   ~PowerMonitorBroadcastSource() override;
 
   void PowerStateChange(bool on_battery_power) override;
diff --git a/chromium/services/device/public/interfaces/power_monitor.mojom b/chromium/services/device/public/interfaces/power_monitor.mojom
index ab2c287d5b3..a6d8701fb07 100644
--- a/chromium/services/device/public/interfaces/power_monitor.mojom
+++ b/chromium/services/device/public/interfaces/power_monitor.mojom
@@ -5,8 +5,8 @@
 module device.mojom;
 
 interface PowerMonitor {
-  // Set client that will be notified on PowerStateChange, Suspend and Resume.
-  SetClient(PowerMonitorClient client);
+  // Add a client that will be notified on PowerStateChange, Suspend and Resume.
+  AddClient(PowerMonitorClient client);
 };
 
 interface PowerMonitorClient {
diff --git a/chromium/services/device/screen_orientation/BUILD.gn b/chromium/services/device/screen_orientation/BUILD.gn
new file mode 100644
index 00000000000..6aa31af0198
--- /dev/null
+++ b/chromium/services/device/screen_orientation/BUILD.gn
@@ -0,0 +1,53 @@
+# 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_android) {
+  import("//build/config/android/rules.gni")  # For generate_jni().
+}
+
+source_set("screen_orientation") {
+  visibility = [ "//services/device:lib" ]
+
+  sources = [
+    "screen_orientation_listener_android.cc",
+    "screen_orientation_listener_android.h",
+  ]
+
+  deps = [
+    "//base",
+    "//mojo/public/cpp/bindings",
+  ]
+
+  public_deps = [
+    "//device/screen_orientation/public/interfaces",
+  ]
+
+  if (is_android) {
+    deps += [ ":screen_orientation_jni_headers" ]
+  }
+}
+
+if (is_android) {
+  generate_jni("screen_orientation_jni_headers") {
+    visibility = [ ":screen_orientation" ]
+    sources = [
+      "android/java/src/org/chromium/device/screen_orientation/ScreenOrientationListener.java",
+    ]
+    jni_package = "screen_orientation"
+  }
+
+  android_library("java") {
+    # Conceptually, this should be visible only to //services/device:java.
+    # However, various generated targets also need to see this target as a
+    # result of //services/device:java depending on it.
+    visibility = [ "//services/device:*" ]
+    java_files = [ "android/java/src/org/chromium/device/screen_orientation/ScreenOrientationListener.java" ]
+    deps = [
+      "//base:base_java",
+      "//ui/android:ui_java",
+    ]
+  }
+}
diff --git a/chromium/services/device/screen_orientation/DEPS b/chromium/services/device/screen_orientation/DEPS
new file mode 100644
index 00000000000..dbaf05111e0
--- /dev/null
+++ b/chromium/services/device/screen_orientation/DEPS
@@ -0,0 +1,4 @@
+include_rules = [
+  "+jni",
+  "+mojo/public/cpp/bindings",
+]
diff --git a/chromium/services/device/screen_orientation/OWNERS b/chromium/services/device/screen_orientation/OWNERS
new file mode 100644
index 00000000000..33ac3a28754
--- /dev/null
+++ b/chromium/services/device/screen_orientation/OWNERS
@@ -0,0 +1,2 @@
+file://device/screen_orientation/OWNERS
+
diff --git a/chromium/services/device/screen_orientation/android/java/DEPS b/chromium/services/device/screen_orientation/android/java/DEPS
new file mode 100644
index 00000000000..05f395ef21d
--- /dev/null
+++ b/chromium/services/device/screen_orientation/android/java/DEPS
@@ -0,0 +1,3 @@
+include_rules = [
+  "+ui/android/java",
+]
diff --git a/chromium/services/device/screen_orientation/screen_orientation_listener_android.cc b/chromium/services/device/screen_orientation/screen_orientation_listener_android.cc
new file mode 100644
index 00000000000..0c863d8b699
--- /dev/null
+++ b/chromium/services/device/screen_orientation/screen_orientation_listener_android.cc
@@ -0,0 +1,58 @@
+// 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/screen_orientation/screen_orientation_listener_android.h"
+
+#include "base/android/jni_android.h"
+#include "base/message_loop/message_loop.h"
+#include "jni/ScreenOrientationListener_jni.h"
+#include "mojo/public/cpp/bindings/strong_binding.h"
+
+namespace device {
+
+// static
+void ScreenOrientationListenerAndroid::Create(
+    mojom::ScreenOrientationListenerRequest request) {
+  mojo::MakeStrongBinding(
+      base::WrapUnique(new ScreenOrientationListenerAndroid()),
+      std::move(request));
+}
+
+ScreenOrientationListenerAndroid::ScreenOrientationListenerAndroid()
+    : listeners_count_(0) {}
+
+ScreenOrientationListenerAndroid::~ScreenOrientationListenerAndroid() {
+  DCHECK(base::MessageLoopForIO::IsCurrent());
+  if (listeners_count_ > 0) {
+    Java_ScreenOrientationListener_startAccurateListening(
+        base::android::AttachCurrentThread());
+  }
+}
+
+void ScreenOrientationListenerAndroid::Start() {
+  DCHECK(base::MessageLoopForIO::IsCurrent());
+  ++listeners_count_;
+  if (listeners_count_ == 1) {
+    // Ask the ScreenOrientationListener (Java) to start accurately listening to
+    // the screen orientation. It keep track of the number of start request if
+    // it is already running an accurate listening.
+    Java_ScreenOrientationListener_startAccurateListening(
+        base::android::AttachCurrentThread());
+  }
+}
+
+void ScreenOrientationListenerAndroid::Stop() {
+  DCHECK(base::MessageLoopForIO::IsCurrent());
+  DCHECK(listeners_count_ > 0);
+  --listeners_count_;
+  if (listeners_count_ == 0) {
+    // Ask the ScreenOrientationListener (Java) to stop accurately listening to
+    // the screen orientation. It will actually stop only if the number of stop
+    // requests matches the number of start requests.
+    Java_ScreenOrientationListener_stopAccurateListening(
+        base::android::AttachCurrentThread());
+  }
+}
+
+}  // namespace device
diff --git a/chromium/services/device/screen_orientation/screen_orientation_listener_android.h b/chromium/services/device/screen_orientation/screen_orientation_listener_android.h
new file mode 100644
index 00000000000..4df873a4346
--- /dev/null
+++ b/chromium/services/device/screen_orientation/screen_orientation_listener_android.h
@@ -0,0 +1,34 @@
+// 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_SCREEN_ORIENTATION_SCREEN_ORIENTATION_LISTENER_ANDROID_H_
+#define SERVICES_DEVICE_SCREEN_ORIENTATION_SCREEN_ORIENTATION_LISTENER_ANDROID_H_
+
+#include "base/macros.h"
+#include "device/screen_orientation/public/interfaces/screen_orientation.mojom.h"
+
+namespace device {
+
+class ScreenOrientationListenerAndroid
+    : public mojom::ScreenOrientationListener {
+ public:
+  static void Create(mojom::ScreenOrientationListenerRequest request);
+
+  ~ScreenOrientationListenerAndroid() override;
+
+ private:
+  ScreenOrientationListenerAndroid();
+
+  // mojom::ScreenOrientationListener:
+  void Start() override;
+  void Stop() override;
+
+  int listeners_count_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScreenOrientationListenerAndroid);
+};
+
+}  // namespace device
+
+#endif  // SERVICES_DEVICE_SCREEN_ORIENTATION_SCREEN_ORIENTATION_LISTENER_ANDROID_H_
diff --git a/chromium/services/device/time_zone_monitor/BUILD.gn b/chromium/services/device/time_zone_monitor/BUILD.gn
index ecef1fc39f5..14cba6d90be 100644
--- a/chromium/services/device/time_zone_monitor/BUILD.gn
+++ b/chromium/services/device/time_zone_monitor/BUILD.gn
@@ -61,4 +61,15 @@ if (is_android) {
     ]
     jni_package = "time_zone_monitor"
   }
+
+  android_library("java") {
+    # Conceptually, this should be visible only to //services/device:java.
+    # However, various generated targets also need to see this target as a
+    # result of //services/device:java depending on it.
+    visibility = [ "//services/device:*" ]
+    java_files = [ "android/java/src/org/chromium/device/time_zone_monitor/TimeZoneMonitor.java" ]
+    deps = [
+      "//base:base_java",
+    ]
+  }
 }
diff --git a/chromium/services/device/unittest_manifest.json b/chromium/services/device/unittest_manifest.json
new file mode 100644
index 00000000000..c743b7b94c4
--- /dev/null
+++ b/chromium/services/device/unittest_manifest.json
@@ -0,0 +1,16 @@
+{
+  "name": "device_unittests",
+  "display_name": "Device Service Unittests",
+  "interface_provider_specs": {
+    "service_manager:connector": {
+      "provides": {
+        "service_manager:service_factory": [
+          "service_manager::mojom::ServiceFactory"
+        ]
+      },
+      "requires": {
+        "device": [ "device:vibration" ]
+      }
+    }
+  }
+}
diff --git a/chromium/services/device/vibration/vibration_manager_impl_unittest.cc b/chromium/services/device/vibration/vibration_manager_impl_unittest.cc
new file mode 100644
index 00000000000..d54a771cff3
--- /dev/null
+++ b/chromium/services/device/vibration/vibration_manager_impl_unittest.cc
@@ -0,0 +1,81 @@
+// 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 "base/run_loop.h"
+#include "device/vibration/vibration_manager.mojom.h"
+#include "services/device/device_service_test_base.h"
+#include "services/device/public/interfaces/constants.mojom.h"
+
+#if defined(OS_ANDROID)
+#include "base/android/jni_android.h"
+#include "jni/VibrationManagerImpl_jni.h"
+#else
+#include "device/vibration/vibration_manager_impl.h"
+#endif
+
+namespace device {
+
+namespace {
+
+class VibrationManagerImplTest : public DeviceServiceTestBase {
+ public:
+  VibrationManagerImplTest() = default;
+  ~VibrationManagerImplTest() override = default;
+
+ protected:
+  void SetUp() override {
+    DeviceServiceTestBase::SetUp();
+
+    connector()->BindInterface(mojom::kServiceName, &vibration_manager_);
+  }
+
+  void Vibrate(int64_t milliseconds) {
+    base::RunLoop run_loop;
+    vibration_manager_->Vibrate(milliseconds, run_loop.QuitClosure());
+    run_loop.Run();
+  }
+
+  void Cancel() {
+    base::RunLoop run_loop;
+    vibration_manager_->Cancel(run_loop.QuitClosure());
+    run_loop.Run();
+  }
+
+  int64_t GetVibrationMilliSeconds() {
+#if defined(OS_ANDROID)
+    return Java_VibrationManagerImpl_getVibrateMilliSecondsForTesting(
+        base::android::AttachCurrentThread());
+#else
+    return VibrationManagerImpl::milli_seconds_for_testing_;
+#endif
+  }
+
+  bool GetVibrationCancelled() {
+#if defined(OS_ANDROID)
+    return Java_VibrationManagerImpl_getVibrateCancelledForTesting(
+        base::android::AttachCurrentThread());
+#else
+    return VibrationManagerImpl::cancelled_for_testing_;
+#endif
+  }
+
+ private:
+  mojom::VibrationManagerPtr vibration_manager_;
+
+  DISALLOW_COPY_AND_ASSIGN(VibrationManagerImplTest);
+};
+
+TEST_F(VibrationManagerImplTest, VibrateThenCancel) {
+  EXPECT_NE(10000, GetVibrationMilliSeconds());
+  Vibrate(10000);
+  EXPECT_EQ(10000, GetVibrationMilliSeconds());
+
+  EXPECT_FALSE(GetVibrationCancelled());
+  Cancel();
+  EXPECT_TRUE(GetVibrationCancelled());
+}
+
+}  // namespace
+
+}  // namespace device