Make DeviceSensorService implement MainLoop::DestructionObserver

services/device/device_service.cc

 // Copyright 2016 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.h"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
+#include "base/message_loop/message_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "base/trace_event/trace_event.h"
+#include "device/sensors/device_sensor_service.h"
 #include "services/device/fingerprint/fingerprint.h"
 #include "services/device/power_monitor/power_monitor_message_broadcaster.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"
 
 #if defined(OS_ANDROID)
 #include "services/device/android/register_jni.h"
 #endif
 
+namespace {
+
+void ShutDownPlatformServices() {
+  TRACE_EVENT0("shutdown", "Subsystem:SensorService");
+  device::DeviceSensorService::GetInstance()->Shutdown();
+}
+
+// IOMessageLoopObserver is responsible for shutdown platform services when it
+// observers IO thread is going to close. It is created by DeviceService in UI
+// thread. When it is notified that the IO thread is closing, it first shut
+// down those platform services, then delete itself. Both the shutdown and self
+// deleting is on IO thread.
+class IOMessageLoopObserver : public base::MessageLoop::DestructionObserver {
+ public:
+  IOMessageLoopObserver(
+      scoped_refptr<base::SingleThreadTaskRunner> io_task_runner)
+      : io_task_runner_(io_task_runner) {
+    DCHECK(io_task_runner_);
+    io_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&IOMessageLoopObserver::AddDestructionObserver,
+                              base::Unretained(this)));
+  }
+
+  // Run in IO thread.
+  void AddDestructionObserver() {
+    DCHECK(io_task_runner_->BelongsToCurrentThread());
+    base::MessageLoop::current()->AddDestructionObserver(this);
+  }
+
+  // base::MessageLoop::DestructionObserver, run in IO thread:
+  void WillDestroyCurrentMessageLoop() override {
+    DCHECK(io_task_runner_ && io_task_runner_->BelongsToCurrentThread());
+    base::MessageLoop::current()->RemoveDestructionObserver(this);
+#if !defined(OS_ANDROID)
+    ShutDownPlatformServices();
+#endif
+    delete this;
+  }
+
+ private:
+  ~IOMessageLoopObserver() override {}
+
+  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
+
+  DISALLOW_COPY_AND_ASSIGN(IOMessageLoopObserver);
+};
+
+}  // namespace
+
 namespace device {
 
 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) {
 #if defined(OS_ANDROID)
   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));
 }
 
 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)) {
+  new IOMessageLoopObserver(io_task_runner_);

[ke.he, 2017/03/07 09:56:41]

Now the IOMessageLoopObserver is created in DeviceService's constructor. The
singleton DeviceSensorService is created after mojo connection has been
established.
So if no client has ever requested DeviceService to create DeviceSensorService,
IOMessageLoopObserver still tries to shutdown the DeviceSensorService. Although
the shutdown code is safe but I guess we should avoid this happen.
One solution is to move the creation of IOMessageLoopObserver into each
DeviceService::Create(). In the DeviceService::Create() we check if
IOMessageLoopObserver has been created already, if yes, do nothing, if no,
create it.
Any comments please? Thanks!

+}
 
-DeviceService::~DeviceService() {}
+DeviceService::~DeviceService() {
+#if defined(OS_ANDROID)
+  ShutDownPlatformServices();

[ke.he, 2017/03/07 09:56:41]

For Android, still shutdown in UI thread. It is safe even occurs before IO
thread close.

+#endif
+}
 
 void DeviceService::OnStart() {}
 
 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;
 }
@@ skipping 13 matching lines @@
 }
 
 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_->Bind(std::move(request));
 }
 
 }  // namespace device