[Device Sensors] Move Mojo communication to UI thread on Android

content/browser/device_sensors/device_sensor_browsertest.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 "base/command_line.h"
 #include "base/macros.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "build/build_config.h"
 #include "content/browser/device_sensors/data_fetcher_shared_memory.h"
@@ skipping 10 matching lines @@
 #include "device/sensors/public/cpp/device_light_hardware_buffer.h"
 #include "device/sensors/public/cpp/device_motion_hardware_buffer.h"
 #include "device/sensors/public/cpp/device_orientation_hardware_buffer.h"
 
 namespace content {
 
 namespace {
 
 class FakeDataFetcher : public DataFetcherSharedMemory {
  public:
-  FakeDataFetcher()
-      : started_orientation_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
-                             base::WaitableEvent::InitialState::NOT_SIGNALED),
-        stopped_orientation_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
-                             base::WaitableEvent::InitialState::NOT_SIGNALED),
-        started_motion_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
-                        base::WaitableEvent::InitialState::NOT_SIGNALED),
-        stopped_motion_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
-                        base::WaitableEvent::InitialState::NOT_SIGNALED),
-        started_light_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
-                       base::WaitableEvent::InitialState::NOT_SIGNALED),
-        stopped_light_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
-                       base::WaitableEvent::InitialState::NOT_SIGNALED),
-        sensor_data_available_(true) {}
+  FakeDataFetcher() : sensor_data_available_(true) {}
   ~FakeDataFetcher() override {}
 
+  void SetMotionStartedCallback(base::Closure motion_started_callback) {
+    motion_started_callback_ = motion_started_callback;
+  }
+
+  void SetMotionStoppedCallback(base::Closure motion_stopped_callback) {
+    motion_stopped_callback_ = motion_stopped_callback;
+  }
+
+  void SetLightStartedCallback(base::Closure light_started_callback) {
+    light_started_callback_ = light_started_callback;
+  }
+
+  void SetLightStoppedCallback(base::Closure light_stopped_callback) {
+    light_stopped_callback_ = light_stopped_callback;
+  }
+
+  void SetOrientationStartedCallback(
+      base::Closure orientation_started_callback) {
+    orientation_started_callback_ = orientation_started_callback;
+  }
+
+  void SetOrientationStoppedCallback(
+      base::Closure orientation_stopped_callback) {
+    orientation_stopped_callback_ = orientation_stopped_callback;
+  }
+
   bool Start(ConsumerType consumer_type, void* buffer) override {
     EXPECT_TRUE(buffer);
 
     switch (consumer_type) {
       case CONSUMER_TYPE_MOTION: {
         DeviceMotionHardwareBuffer* motion_buffer =
             static_cast<DeviceMotionHardwareBuffer*>(buffer);
         if (sensor_data_available_)
           UpdateMotion(motion_buffer);
         SetMotionBufferReady(motion_buffer);
-        started_motion_.Signal();
+        BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                                motion_started_callback_);
       } break;
       case CONSUMER_TYPE_ORIENTATION: {
         DeviceOrientationHardwareBuffer* orientation_buffer =
             static_cast<DeviceOrientationHardwareBuffer*>(buffer);
         if (sensor_data_available_)
           UpdateOrientation(orientation_buffer);
         SetOrientationBufferReady(orientation_buffer);
-        started_orientation_.Signal();
+        BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                                orientation_started_callback_);
       } break;
       case CONSUMER_TYPE_LIGHT: {
         DeviceLightHardwareBuffer* light_buffer =
             static_cast<DeviceLightHardwareBuffer*>(buffer);
         UpdateLight(light_buffer,
                     sensor_data_available_
                         ? 100
                         : std::numeric_limits<double>::infinity());
-        started_light_.Signal();
+        BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                                light_started_callback_);
       } break;
       default:
         return false;
     }
     return true;
   }
 
   bool Stop(ConsumerType consumer_type) override {
     switch (consumer_type) {
       case CONSUMER_TYPE_MOTION:
-        stopped_motion_.Signal();
+        BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                                motion_stopped_callback_);
         break;
       case CONSUMER_TYPE_ORIENTATION:
-        stopped_orientation_.Signal();
+        BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                                orientation_stopped_callback_);
         break;
       case CONSUMER_TYPE_LIGHT:
-        stopped_light_.Signal();
+        BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                                light_stopped_callback_);
         break;
       default:
         return false;
     }
     return true;
   }
 
   void Fetch(unsigned consumer_bitmask) override {
     FAIL() << "fetch should not be called";
   }
@@ skipping 55 matching lines @@
     buffer->data.allAvailableSensorsAreActive = true;
     buffer->seqlock.WriteEnd();
   }
 
   void UpdateLight(DeviceLightHardwareBuffer* buffer, double lux) {
     buffer->seqlock.WriteBegin();
     buffer->data.value = lux;
     buffer->seqlock.WriteEnd();
   }
 
-  base::WaitableEvent started_orientation_;
-  base::WaitableEvent stopped_orientation_;
-  base::WaitableEvent started_motion_;
-  base::WaitableEvent stopped_motion_;
-  base::WaitableEvent started_light_;
-  base::WaitableEvent stopped_light_;
+  // The below callbacks should be run on the UI thread.
+  base::Closure motion_started_callback_;
+  base::Closure orientation_started_callback_;
+  base::Closure light_started_callback_;
+  base::Closure motion_stopped_callback_;
+  base::Closure orientation_stopped_callback_;
+  base::Closure light_stopped_callback_;
   bool sensor_data_available_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FakeDataFetcher);
 };
 
 class DeviceSensorBrowserTest : public ContentBrowserTest {
  public:
   DeviceSensorBrowserTest()
       : fetcher_(nullptr),
         io_loop_finished_event_(
             base::WaitableEvent::ResetPolicy::AUTOMATIC,
             base::WaitableEvent::InitialState::NOT_SIGNALED) {}
 
   void SetUpOnMainThread() override {
+#if defined(OS_ANDROID)
+    // On Android, the DeviceSensorService lives on the UI thread.
+    SetUpFetcher();
+#else
+    // On all other platforms, the DeviceSensorService lives on the IO thread.
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&DeviceSensorBrowserTest::SetUpOnIOThread,
                    base::Unretained(this)));
     io_loop_finished_event_.Wait();
+#endif
+  }
+
+  void SetUpFetcher() {
+    fetcher_ = new FakeDataFetcher();
+    DeviceSensorService::GetInstance()->SetDataFetcherForTesting(fetcher_);
   }
 
   void SetUpOnIOThread() {
-    fetcher_ = new FakeDataFetcher();
-    DeviceSensorService::GetInstance()->SetDataFetcherForTesting(fetcher_);
+    SetUpFetcher();
     io_loop_finished_event_.Signal();
   }
 
   void DelayAndQuit(base::TimeDelta delay) {
     base::PlatformThread::Sleep(delay);
     base::MessageLoop::current()->QuitWhenIdle();
   }
 
   void WaitForAlertDialogAndQuitAfterDelay(base::TimeDelta delay) {
     ShellJavaScriptDialogManager* dialog_manager =
@@ skipping 14 matching lines @@
       cmd_line->AppendSwitch(switches::kEnableExperimentalWebPlatformFeatures);
   }
 
   FakeDataFetcher* fetcher_;
 
  private:
   base::WaitableEvent io_loop_finished_event_;
 };
 
 IN_PROC_BROWSER_TEST_F(DeviceSensorBrowserTest, OrientationTest) {
+  base::RunLoop orientation_started_runloop;
+  fetcher_->SetOrientationStartedCallback(
+      orientation_started_runloop.QuitClosure());
+  base::RunLoop orientation_stopped_runloop;
+  fetcher_->SetOrientationStoppedCallback(
+      orientation_stopped_runloop.QuitClosure());
+
   // The test page will register an event handler for orientation events,
   // expects to get an event with fake values, then removes the event
   // handler and navigates to #pass.
   GURL test_url = GetTestUrl("device_sensors", "device_orientation_test.html");
   NavigateToURLBlockUntilNavigationsComplete(shell(), test_url, 2);
 
   EXPECT_EQ("pass", shell()->web_contents()->GetLastCommittedURL().ref());
-  fetcher_->started_orientation_.Wait();
-  fetcher_->stopped_orientation_.Wait();
+  orientation_started_runloop.Run();
+  orientation_stopped_runloop.Run();
 }
 
 IN_PROC_BROWSER_TEST_F(DeviceSensorBrowserTest, LightTest) {
+  base::RunLoop light_started_runloop;
+  fetcher_->SetLightStartedCallback(light_started_runloop.QuitClosure());
+  base::RunLoop light_stopped_runloop;
+  fetcher_->SetLightStoppedCallback(light_stopped_runloop.QuitClosure());
+
   // The test page will register an event handler for light events,
   // expects to get an event with fake values, then removes the event
   // handler and navigates to #pass.
   EnableExperimentalFeatures();
   GURL test_url = GetTestUrl("device_sensors", "device_light_test.html");
   NavigateToURLBlockUntilNavigationsComplete(shell(), test_url, 2);
 
   EXPECT_EQ("pass", shell()->web_contents()->GetLastCommittedURL().ref());
-  fetcher_->started_light_.Wait();
-  fetcher_->stopped_light_.Wait();
+  light_started_runloop.Run();
+  light_stopped_runloop.Run();
 }
 
 IN_PROC_BROWSER_TEST_F(DeviceSensorBrowserTest, MotionTest) {
+  base::RunLoop motion_started_runloop;
+  fetcher_->SetMotionStartedCallback(motion_started_runloop.QuitClosure());
+  base::RunLoop motion_stopped_runloop;
+  fetcher_->SetMotionStoppedCallback(motion_stopped_runloop.QuitClosure());
+
   // The test page will register an event handler for motion events,
   // expects to get an event with fake values, then removes the event
   // handler and navigates to #pass.
   GURL test_url = GetTestUrl("device_sensors", "device_motion_test.html");
   NavigateToURLBlockUntilNavigationsComplete(shell(), test_url, 2);
 
   EXPECT_EQ("pass", shell()->web_contents()->GetLastCommittedURL().ref());
-  fetcher_->started_motion_.Wait();
-  fetcher_->stopped_motion_.Wait();
+  motion_started_runloop.Run();
+  motion_stopped_runloop.Run();
 }
 
 IN_PROC_BROWSER_TEST_F(DeviceSensorBrowserTest, LightOneOffInfintyTest) {
+  base::RunLoop light_started_runloop;
+  fetcher_->SetLightStartedCallback(light_started_runloop.QuitClosure());
+  base::RunLoop light_stopped_runloop;
+  fetcher_->SetLightStoppedCallback(light_stopped_runloop.QuitClosure());
+
   // The test page registers an event handler for light events and expects
   // to get an event with value equal to infinity, because no sensor data can
   // be provided.
   EnableExperimentalFeatures();
   fetcher_->SetSensorDataAvailable(false);
   GURL test_url =
       GetTestUrl("device_sensors", "device_light_infinity_test.html");
   NavigateToURLBlockUntilNavigationsComplete(shell(), test_url, 2);
 
   EXPECT_EQ("pass", shell()->web_contents()->GetLastCommittedURL().ref());
-  fetcher_->started_light_.Wait();
-  fetcher_->stopped_light_.Wait();
+  light_started_runloop.Run();
+  light_stopped_runloop.Run();
 }
 
 IN_PROC_BROWSER_TEST_F(DeviceSensorBrowserTest, OrientationNullTest) {
+  base::RunLoop orientation_started_runloop;
+  fetcher_->SetOrientationStartedCallback(
+      orientation_started_runloop.QuitClosure());
+  base::RunLoop orientation_stopped_runloop;
+  fetcher_->SetOrientationStoppedCallback(
+      orientation_stopped_runloop.QuitClosure());
+
   // The test page registers an event handler for orientation events and
   // expects to get an event with null values, because no sensor data can be
   // provided.
   fetcher_->SetSensorDataAvailable(false);
   GURL test_url =
       GetTestUrl("device_sensors", "device_orientation_null_test.html");
   NavigateToURLBlockUntilNavigationsComplete(shell(), test_url, 2);
 
   EXPECT_EQ("pass", shell()->web_contents()->GetLastCommittedURL().ref());
-  fetcher_->started_orientation_.Wait();
-  fetcher_->stopped_orientation_.Wait();
+  orientation_started_runloop.Run();
+  orientation_stopped_runloop.Run();
 }
 
 IN_PROC_BROWSER_TEST_F(DeviceSensorBrowserTest, MotionNullTest) {
+  base::RunLoop motion_started_runloop;
+  fetcher_->SetMotionStartedCallback(motion_started_runloop.QuitClosure());
+  base::RunLoop motion_stopped_runloop;
+  fetcher_->SetMotionStoppedCallback(motion_stopped_runloop.QuitClosure());
+
   // The test page registers an event handler for motion events and
   // expects to get an event with null values, because no sensor data can be
   // provided.
   fetcher_->SetSensorDataAvailable(false);
   GURL test_url = GetTestUrl("device_sensors", "device_motion_null_test.html");
   NavigateToURLBlockUntilNavigationsComplete(shell(), test_url, 2);
 
   EXPECT_EQ("pass", shell()->web_contents()->GetLastCommittedURL().ref());
-  fetcher_->started_motion_.Wait();
-  fetcher_->stopped_motion_.Wait();
+  motion_started_runloop.Run();
+  motion_stopped_runloop.Run();
 }
 
 IN_PROC_BROWSER_TEST_F(DeviceSensorBrowserTest, NullTestWithAlert) {
-  // The test page registers an event handlers for motion/orientation events
+  base::RunLoop motion_started_runloop;

[timvolodine, 2016/10/31 15:51:44]

would it be simpler to just declare run loops in the test fixture? then there
would be no need for creating loops and setting callbacks in every test (and
would look more like the waitable events)

[blundell, 2016/11/09 15:07:43]

Good idea, done.

+  fetcher_->SetMotionStartedCallback(motion_started_runloop.QuitClosure());
+  base::RunLoop motion_stopped_runloop;
+  fetcher_->SetMotionStoppedCallback(motion_stopped_runloop.QuitClosure());
+  base::RunLoop orientation_started_runloop;
+  fetcher_->SetOrientationStartedCallback(
+      orientation_started_runloop.QuitClosure());
+  base::RunLoop orientation_stopped_runloop;
+  fetcher_->SetOrientationStoppedCallback(
+      orientation_stopped_runloop.QuitClosure());
+
+  // The test page registers an event handlers for orientation/orientation
+  // events
   // and expects to get events with null values. The test raises a modal alert
   // dialog with a delay to test that the one-off null-events still propagate
   // to window after the alert is dismissed and the callbacks are invoked which
   // eventually navigate to #pass.
   fetcher_->SetSensorDataAvailable(false);
   TestNavigationObserver same_tab_observer(shell()->web_contents(), 2);
 
   GURL test_url =
       GetTestUrl("device_sensors", "device_sensors_null_test_with_alert.html");
   shell()->LoadURL(test_url);
 
   // TODO(timvolodine): investigate if it is possible to test this without
   // delay, crbug.com/360044.
   WaitForAlertDialogAndQuitAfterDelay(base::TimeDelta::FromMilliseconds(500));
 
-  fetcher_->started_motion_.Wait();
-  fetcher_->stopped_motion_.Wait();
-  fetcher_->started_orientation_.Wait();
-  fetcher_->stopped_orientation_.Wait();
+  motion_started_runloop.Run();
+  motion_stopped_runloop.Run();
+  orientation_started_runloop.Run();
+  orientation_stopped_runloop.Run();
   same_tab_observer.Wait();
   EXPECT_EQ("pass", shell()->web_contents()->GetLastCommittedURL().ref());
 }
 
 }  //  namespace
 
 }  //  namespace content