src/content/browser/device_sensors/device_inertial_sensor_browsertest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/command_line.h"
   6 #include "base/synchronization/waitable_event.h"
   7 #include "base/threading/platform_thread.h"
   8 #include "content/browser/device_sensors/data_fetcher_shared_memory.h"
   9 #include "content/browser/device_sensors/device_inertial_sensor_service.h"
  10 #include "content/common/device_sensors/device_light_hardware_buffer.h"
  11 #include "content/common/device_sensors/device_motion_hardware_buffer.h"
  12 #include "content/common/device_sensors/device_orientation_hardware_buffer.h"
  13 #include "content/public/browser/browser_thread.h"
  14 #include "content/public/browser/web_contents.h"
  15 #include "content/public/common/content_switches.h"
  16 #include "content/public/test/content_browser_test.h"
  17 #include "content/public/test/content_browser_test_utils.h"
  18 #include "content/public/test/test_navigation_observer.h"
  19 #include "content/public/test/test_utils.h"
  20 #include "content/shell/browser/shell.h"
  21 #include "content/shell/browser/shell_javascript_dialog_manager.h"
  22
  23 namespace content {
  24
  25 namespace {
  26
  27 class FakeDataFetcher : public DataFetcherSharedMemory {
  28  public:
  29   FakeDataFetcher()
  30       : started_orientation_(false, false),
  31         stopped_orientation_(false, false),
  32         started_motion_(false, false),
  33         stopped_motion_(false, false),
  34         started_light_(false, false),
  35         stopped_light_(false, false),
  36         sensor_data_available_(true) {}
  37   virtual ~FakeDataFetcher() { }
  38
  39   virtual bool Start(ConsumerType consumer_type, void* buffer) OVERRIDE {
  40     EXPECT_TRUE(buffer);
  41
  42     switch (consumer_type) {
  43       case CONSUMER_TYPE_MOTION:
  44         {
  45           DeviceMotionHardwareBuffer* motion_buffer =
  46               static_cast<DeviceMotionHardwareBuffer*>(buffer);
  47           if (sensor_data_available_)
  48             UpdateMotion(motion_buffer);
  49           SetMotionBufferReady(motion_buffer);
  50           started_motion_.Signal();
  51         }
  52         break;
  53       case CONSUMER_TYPE_ORIENTATION:
  54         {
  55           DeviceOrientationHardwareBuffer* orientation_buffer =
  56               static_cast<DeviceOrientationHardwareBuffer*>(buffer);
  57           if (sensor_data_available_)
  58             UpdateOrientation(orientation_buffer);
  59           SetOrientationBufferReady(orientation_buffer);
  60           started_orientation_.Signal();
  61         }
  62         break;
  63       case CONSUMER_TYPE_LIGHT:
  64         {
  65           DeviceLightHardwareBuffer* light_buffer =
  66               static_cast<DeviceLightHardwareBuffer*>(buffer);
  67           UpdateLight(light_buffer,
  68                       sensor_data_available_
  69                           ? 100
  70                           : std::numeric_limits<double>::infinity());
  71           started_light_.Signal();
  72         }
  73         break;
  74       default:
  75         return false;
  76     }
  77     return true;
  78   }
  79
  80   virtual bool Stop(ConsumerType consumer_type) OVERRIDE {
  81     switch (consumer_type) {
  82       case CONSUMER_TYPE_MOTION:
  83         stopped_motion_.Signal();
  84         break;
  85       case CONSUMER_TYPE_ORIENTATION:
  86         stopped_orientation_.Signal();
  87         break;
  88       case CONSUMER_TYPE_LIGHT:
  89         stopped_light_.Signal();
  90         break;
  91       default:
  92         return false;
  93     }
  94     return true;
  95   }
  96
  97   virtual void Fetch(unsigned consumer_bitmask) OVERRIDE {
  98     FAIL() << "fetch should not be called";
  99   }
 100
 101   virtual FetcherType GetType() const OVERRIDE {
 102     return FETCHER_TYPE_DEFAULT;
 103   }
 104
 105   void SetSensorDataAvailable(bool available) {
 106     sensor_data_available_ = available;
 107   }
 108
 109   void SetMotionBufferReady(DeviceMotionHardwareBuffer* buffer) {
 110     buffer->seqlock.WriteBegin();
 111     buffer->data.allAvailableSensorsAreActive = true;
 112     buffer->seqlock.WriteEnd();
 113   }
 114
 115   void SetOrientationBufferReady(DeviceOrientationHardwareBuffer* buffer) {
 116     buffer->seqlock.WriteBegin();
 117     buffer->data.allAvailableSensorsAreActive = true;
 118     buffer->seqlock.WriteEnd();
 119   }
 120
 121   void UpdateMotion(DeviceMotionHardwareBuffer* buffer) {
 122     buffer->seqlock.WriteBegin();
 123     buffer->data.accelerationX = 1;
 124     buffer->data.hasAccelerationX = true;
 125     buffer->data.accelerationY = 2;
 126     buffer->data.hasAccelerationY = true;
 127     buffer->data.accelerationZ = 3;
 128     buffer->data.hasAccelerationZ = true;
 129
 130     buffer->data.accelerationIncludingGravityX = 4;
 131     buffer->data.hasAccelerationIncludingGravityX = true;
 132     buffer->data.accelerationIncludingGravityY = 5;
 133     buffer->data.hasAccelerationIncludingGravityY = true;
 134     buffer->data.accelerationIncludingGravityZ = 6;
 135     buffer->data.hasAccelerationIncludingGravityZ = true;
 136
 137     buffer->data.rotationRateAlpha = 7;
 138     buffer->data.hasRotationRateAlpha = true;
 139     buffer->data.rotationRateBeta = 8;
 140     buffer->data.hasRotationRateBeta = true;
 141     buffer->data.rotationRateGamma = 9;
 142     buffer->data.hasRotationRateGamma = true;
 143
 144     buffer->data.interval = 100;
 145     buffer->data.allAvailableSensorsAreActive = true;
 146     buffer->seqlock.WriteEnd();
 147   }
 148
 149   void UpdateOrientation(DeviceOrientationHardwareBuffer* buffer) {
 150     buffer->seqlock.WriteBegin();
 151     buffer->data.alpha = 1;
 152     buffer->data.hasAlpha = true;
 153     buffer->data.beta = 2;
 154     buffer->data.hasBeta = true;
 155     buffer->data.gamma = 3;
 156     buffer->data.hasGamma = true;
 157     buffer->data.allAvailableSensorsAreActive = true;
 158     buffer->seqlock.WriteEnd();
 159   }
 160
 161   void UpdateLight(DeviceLightHardwareBuffer* buffer, double lux) {
 162     buffer->seqlock.WriteBegin();
 163     buffer->data.value = lux;
 164     buffer->seqlock.WriteEnd();
 165   }
 166
 167   base::WaitableEvent started_orientation_;
 168   base::WaitableEvent stopped_orientation_;
 169   base::WaitableEvent started_motion_;
 170   base::WaitableEvent stopped_motion_;
 171   base::WaitableEvent started_light_;
 172   base::WaitableEvent stopped_light_;
 173   bool sensor_data_available_;
 174
 175  private:
 176   DISALLOW_COPY_AND_ASSIGN(FakeDataFetcher);
 177 };
 178
 179
 180 class DeviceInertialSensorBrowserTest : public ContentBrowserTest  {
 181  public:
 182   DeviceInertialSensorBrowserTest()
 183       : fetcher_(NULL),
 184         io_loop_finished_event_(false, false) {
 185   }
 186
 187   virtual void SetUpOnMainThread() OVERRIDE {
 188     BrowserThread::PostTask(
 189         BrowserThread::IO, FROM_HERE,
 190         base::Bind(&DeviceInertialSensorBrowserTest::SetUpOnIOThread, this));
 191     io_loop_finished_event_.Wait();
 192   }
 193
 194   void SetUpOnIOThread() {
 195     fetcher_ = new FakeDataFetcher();
 196     DeviceInertialSensorService::GetInstance()->
 197         SetDataFetcherForTesting(fetcher_);
 198     io_loop_finished_event_.Signal();
 199   }
 200
 201   void DelayAndQuit(base::TimeDelta delay) {
 202     base::PlatformThread::Sleep(delay);
 203     base::MessageLoop::current()->QuitWhenIdle();
 204   }
 205
 206   void WaitForAlertDialogAndQuitAfterDelay(base::TimeDelta delay) {
 207     ShellJavaScriptDialogManager* dialog_manager=
 208         static_cast<ShellJavaScriptDialogManager*>(
 209             shell()->GetJavaScriptDialogManager());
 210
 211     scoped_refptr<MessageLoopRunner> runner = new MessageLoopRunner();
 212     dialog_manager->set_dialog_request_callback(
 213         base::Bind(&DeviceInertialSensorBrowserTest::DelayAndQuit, this,
 214             delay));
 215     runner->Run();
 216   }
 217
 218   FakeDataFetcher* fetcher_;
 219
 220  private:
 221   base::WaitableEvent io_loop_finished_event_;
 222 };
 223
 224 IN_PROC_BROWSER_TEST_F(DeviceInertialSensorBrowserTest, OrientationTest) {
 225   // The test page will register an event handler for orientation events,
 226   // expects to get an event with fake values, then removes the event
 227   // handler and navigates to #pass.
 228   GURL test_url = GetTestUrl("device_sensors", "device_orientation_test.html");
 229   NavigateToURLBlockUntilNavigationsComplete(shell(), test_url, 2);
 230
 231   EXPECT_EQ("pass", shell()->web_contents()->GetLastCommittedURL().ref());
 232   fetcher_->started_orientation_.Wait();
 233   fetcher_->stopped_orientation_.Wait();
 234 }
 235
 236 IN_PROC_BROWSER_TEST_F(DeviceInertialSensorBrowserTest, LightTest) {
 237   // The test page will register an event handler for light events,
 238   // expects to get an event with fake values, then removes the event
 239   // handler and navigates to #pass.
 240   GURL test_url = GetTestUrl("device_sensors", "device_light_test.html");
 241
 242   // TODO(riju): remove command line args when the feature goes stable.
 243   if (!CommandLine::ForCurrentProcess()->HasSwitch(
 244       switches::kEnableExperimentalWebPlatformFeatures)) {
 245     CommandLine::ForCurrentProcess()->AppendSwitch(
 246         switches::kEnableExperimentalWebPlatformFeatures);
 247   }
 248
 249   NavigateToURLBlockUntilNavigationsComplete(shell(), test_url, 2);
 250
 251   EXPECT_EQ("pass", shell()->web_contents()->GetLastCommittedURL().ref());
 252   fetcher_->started_light_.Wait();
 253   fetcher_->stopped_light_.Wait();
 254 }
 255
 256 IN_PROC_BROWSER_TEST_F(DeviceInertialSensorBrowserTest, MotionTest) {
 257   // The test page will register an event handler for motion events,
 258   // expects to get an event with fake values, then removes the event
 259   // handler and navigates to #pass.
 260   GURL test_url = GetTestUrl("device_sensors", "device_motion_test.html");
 261   NavigateToURLBlockUntilNavigationsComplete(shell(), test_url, 2);
 262
 263   EXPECT_EQ("pass", shell()->web_contents()->GetLastCommittedURL().ref());
 264   fetcher_->started_motion_.Wait();
 265   fetcher_->stopped_motion_.Wait();
 266 }
 267
 268 // crbug/416406. The test is flaky.
 269 IN_PROC_BROWSER_TEST_F(DeviceInertialSensorBrowserTest,
 270                        DISABLED_LightOneOffInfintyTest) {
 271   // The test page will register an event handler for light events,
 272   // expects to get an event with value equal to Infinity. This tests that the
 273   // one-off infinity event still propagates to window after the alert is
 274   // dismissed and the callback is invoked which navigates to #pass.
 275   fetcher_->SetSensorDataAvailable(false);
 276
 277   // TODO(riju): remove command line args when the feature goes stable.
 278   if (!CommandLine::ForCurrentProcess()->HasSwitch(
 279       switches::kEnableExperimentalWebPlatformFeatures)) {
 280     CommandLine::ForCurrentProcess()->AppendSwitch(
 281         switches::kEnableExperimentalWebPlatformFeatures);
 282   }
 283
 284   TestNavigationObserver same_tab_observer(shell()->web_contents(), 2);
 285
 286   GURL test_url =
 287       GetTestUrl("device_sensors", "device_light_infinity_test.html");
 288   shell()->LoadURL(test_url);
 289
 290   WaitForAlertDialogAndQuitAfterDelay(base::TimeDelta::FromMilliseconds(1000));
 291
 292   fetcher_->started_light_.Wait();
 293   fetcher_->stopped_light_.Wait();
 294   same_tab_observer.Wait();
 295   EXPECT_EQ("pass", shell()->web_contents()->GetLastCommittedURL().ref());
 296 }
 297
 298 // Flaking in the android try bot. See http://crbug.com/360578.
 299 #if defined(OS_ANDROID)
 300 #define MAYBE_OrientationNullTestWithAlert DISABLED_OrientationNullTestWithAlert
 301 #else
 302 #define MAYBE_OrientationNullTestWithAlert OrientationNullTestWithAlert
 303 #endif
 304 IN_PROC_BROWSER_TEST_F(DeviceInertialSensorBrowserTest,
 305     MAYBE_OrientationNullTestWithAlert) {
 306   // The test page will register an event handler for orientation events,
 307   // expects to get an event with null values. The test raises a modal alert
 308   // dialog with a delay to test that the one-off null-event still propagates
 309   // to window after the alert is dismissed and the callback is invoked which
 310   // navigates to #pass.
 311   fetcher_->SetSensorDataAvailable(false);
 312   TestNavigationObserver same_tab_observer(shell()->web_contents(), 2);
 313
 314   GURL test_url = GetTestUrl("device_sensors",
 315                              "device_orientation_null_test_with_alert.html");
 316   shell()->LoadURL(test_url);
 317
 318   // TODO(timvolodine): investigate if it is possible to test this without
 319   // delay, crbug.com/360044.
 320   WaitForAlertDialogAndQuitAfterDelay(base::TimeDelta::FromMilliseconds(1000));
 321
 322   fetcher_->started_orientation_.Wait();
 323   fetcher_->stopped_orientation_.Wait();
 324   same_tab_observer.Wait();
 325   EXPECT_EQ("pass", shell()->web_contents()->GetLastCommittedURL().ref());
 326 }
 327
 328 // Flaking in the android try bot. See http://crbug.com/360578.
 329 #if defined(OS_ANDROID)
 330 #define MAYBE_MotionNullTestWithAlert DISABLED_MotionNullTestWithAlert
 331 #else
 332 #define MAYBE_MotionNullTestWithAlert MotionNullTestWithAlert
 333 #endif
 334 IN_PROC_BROWSER_TEST_F(DeviceInertialSensorBrowserTest,
 335     MAYBE_MotionNullTestWithAlert) {
 336   // The test page will register an event handler for motion events,
 337   // expects to get an event with null values. The test raises a modal alert
 338   // dialog with a delay to test that the one-off null-event still propagates
 339   // to window after the alert is dismissed and the callback is invoked which
 340   // navigates to #pass.
 341   fetcher_->SetSensorDataAvailable(false);
 342   TestNavigationObserver same_tab_observer(shell()->web_contents(), 2);
 343
 344   GURL test_url =
 345       GetTestUrl("device_sensors", "device_motion_null_test_with_alert.html");
 346   shell()->LoadURL(test_url);
 347
 348   // TODO(timvolodine): investigate if it is possible to test this without
 349   // delay, crbug.com/360044.
 350   WaitForAlertDialogAndQuitAfterDelay(base::TimeDelta::FromMilliseconds(1000));
 351
 352   fetcher_->started_motion_.Wait();
 353   fetcher_->stopped_motion_.Wait();
 354   same_tab_observer.Wait();
 355   EXPECT_EQ("pass", shell()->web_contents()->GetLastCommittedURL().ref());
 356 }
 357
 358 }  //  namespace
 359
 360 }  //  namespace content