Remove content::BrowserThread knowledge from Device Sensors

content/browser/device_sensors/device_sensor_service.cc

 // Copyright 2014 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 "content/browser/device_sensors/device_sensor_service.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
+#include "build/build_config.h"
 #include "content/browser/device_sensors/data_fetcher_shared_memory.h"
 
+#if defined(OS_ANDROID)
+#include "content/browser/device_sensors/sensor_manager_android.h"
+#endif
+
 namespace content {
 
 DeviceSensorService::DeviceSensorService()
     : num_light_readers_(0),
       num_motion_readers_(0),
       num_orientation_readers_(0),
       num_orientation_absolute_readers_(0),
       is_shutdown_(false) {}
 
 DeviceSensorService::~DeviceSensorService() {}
@@ skipping 17 matching lines @@
 void DeviceSensorService::RemoveConsumer(ConsumerType consumer_type) {
   if (!ChangeNumberConsumers(consumer_type, -1))
     return;
 
   if (GetNumberConsumers(consumer_type) == 0)
     data_fetcher_->StopFetchingDeviceData(consumer_type);
 }
 
 bool DeviceSensorService::ChangeNumberConsumers(ConsumerType consumer_type,
                                                 int delta) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(io_thread_checker_.CalledOnValidThread());
   if (is_shutdown_)
     return false;
 
   switch (consumer_type) {
     case CONSUMER_TYPE_MOTION:
       num_motion_readers_ += delta;
       DCHECK_GE(num_motion_readers_, 0);
       return true;
     case CONSUMER_TYPE_ORIENTATION:
       num_orientation_readers_ += delta;
@@ skipping 24 matching lines @@
     case CONSUMER_TYPE_LIGHT:
       return num_light_readers_;
     default:
       NOTREACHED();
   }
   return 0;
 }
 
 mojo::ScopedSharedBufferHandle DeviceSensorService::GetSharedMemoryHandle(
     ConsumerType consumer_type) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(io_thread_checker_.CalledOnValidThread());
   return data_fetcher_->GetSharedMemoryHandle(consumer_type);
 }
 
-void DeviceSensorService::Shutdown() {
+void DeviceSensorService::InitOnUIThread() {
+#if defined(OS_ANDROID)
+  SensorManagerAndroid::GetInstance()->InitOnUIThread();
+#endif
+}
+
+void DeviceSensorService::InitOnIOThread() {

[timvolodine, 2016/10/12 16:28:58]

I am slightly confused by the two Init methods, with the first only doing
something for android, while the second seems a bit 'hacky'. Is there a way to
limit the change to android (and drop the InitOnIOThread/UIThread)?

A few ideas: maybe by either putting the ifdef block in InitOnUIThread in
browser_main_loop.cc directly.. or maybe even better to let the mojo IPC arrive
on UI thread for android and set the taskrunner there since most android calls
happen on UI anyway. That way we avoid the overhead of constructing
sensor_manager_android and its java counterpart on each startup. wdyt?

+  // Ensure that the thread checker is associated with the IO thread in case
+  // instantiation of this object occurred on the UI thread.
+  io_thread_checker_.DetachFromThread();
+  ignore_result(io_thread_checker_.CalledOnValidThread());
+}
+
+void DeviceSensorService::ShutDownOnUIThread() {
   if (data_fetcher_) {
-    data_fetcher_->Shutdown();
+    data_fetcher_->ShutDownOnUIThread();
     data_fetcher_.reset();
   }
   is_shutdown_ = true;
 }
 
 void DeviceSensorService::SetDataFetcherForTesting(
     DataFetcherSharedMemory* test_data_fetcher) {
   if (data_fetcher_)
-    data_fetcher_->Shutdown();
+    data_fetcher_->ShutDownOnUIThread();
   data_fetcher_.reset(test_data_fetcher);
 }
 
 }  // namespace content