Home | History | Annotate | Download | only in device_sensors 
      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_motion_hardware_buffer.h"
     11 #include "content/common/device_sensors/device_orientation_hardware_buffer.h"
     12 #include "content/public/browser/browser_thread.h"
     13 #include "content/public/browser/web_contents.h"
     14 #include "content/public/common/content_switches.h"
     15 #include "content/public/test/content_browser_test.h"
     16 #include "content/public/test/content_browser_test_utils.h"
     17 #include "content/public/test/test_navigation_observer.h"
     18 #include "content/public/test/test_utils.h"
     19 #include "content/shell/browser/shell.h"
     20 #include "content/shell/browser/shell_javascript_dialog_manager.h"
     21 
     22 namespace content {
     23 
     24 namespace {
     25 
     26 class FakeDataFetcher : public DataFetcherSharedMemory {
     27  public:
     28   FakeDataFetcher()
     29       : started_orientation_(false, false),
     30         stopped_orientation_(false, false),
     31         started_motion_(false, false),
     32         stopped_motion_(false, false),
     33         sensor_data_available_(true) {
     34   }
     35   virtual ~FakeDataFetcher() { }
     36 
     37   virtual bool Start(ConsumerType consumer_type, void* buffer) OVERRIDE {
     38     EXPECT_TRUE(buffer);
     39 
     40     switch (consumer_type) {
     41       case CONSUMER_TYPE_MOTION:
     42         {
     43           DeviceMotionHardwareBuffer* motion_buffer =
     44               static_cast<DeviceMotionHardwareBuffer*>(buffer);
     45           if (sensor_data_available_)
     46             UpdateMotion(motion_buffer);
     47           SetMotionBufferReady(motion_buffer);
     48           started_motion_.Signal();
     49         }
     50         break;
     51       case CONSUMER_TYPE_ORIENTATION:
     52         {
     53           DeviceOrientationHardwareBuffer* orientation_buffer =
     54               static_cast<DeviceOrientationHardwareBuffer*>(buffer);
     55           if (sensor_data_available_)
     56             UpdateOrientation(orientation_buffer);
     57           SetOrientationBufferReady(orientation_buffer);
     58           started_orientation_.Signal();
     59         }
     60         break;
     61       default:
     62         return false;
     63     }
     64     return true;
     65   }
     66 
     67   virtual bool Stop(ConsumerType consumer_type) OVERRIDE {
     68     switch (consumer_type) {
     69       case CONSUMER_TYPE_MOTION:
     70         stopped_motion_.Signal();
     71         break;
     72       case CONSUMER_TYPE_ORIENTATION:
     73         stopped_orientation_.Signal();
     74         break;
     75       default:
     76         return false;
     77     }
     78     return true;
     79   }
     80 
     81   virtual void Fetch(unsigned consumer_bitmask) OVERRIDE {
     82     FAIL() << "fetch should not be called";
     83   }
     84 
     85   virtual FetcherType GetType() const OVERRIDE {
     86     return FETCHER_TYPE_DEFAULT;
     87   }
     88 
     89   void SetSensorDataAvailable(bool available) {
     90     sensor_data_available_ = available;
     91   }
     92 
     93   void SetMotionBufferReady(DeviceMotionHardwareBuffer* buffer) {
     94     buffer->seqlock.WriteBegin();
     95     buffer->data.allAvailableSensorsAreActive = true;
     96     buffer->seqlock.WriteEnd();
     97   }
     98 
     99   void SetOrientationBufferReady(DeviceOrientationHardwareBuffer* buffer) {
    100     buffer->seqlock.WriteBegin();
    101     buffer->data.allAvailableSensorsAreActive = true;
    102     buffer->seqlock.WriteEnd();
    103   }
    104 
    105   void UpdateMotion(DeviceMotionHardwareBuffer* buffer) {
    106     buffer->seqlock.WriteBegin();
    107     buffer->data.accelerationX = 1;
    108     buffer->data.hasAccelerationX = true;
    109     buffer->data.accelerationY = 2;
    110     buffer->data.hasAccelerationY = true;
    111     buffer->data.accelerationZ = 3;
    112     buffer->data.hasAccelerationZ = true;
    113 
    114     buffer->data.accelerationIncludingGravityX = 4;
    115     buffer->data.hasAccelerationIncludingGravityX = true;
    116     buffer->data.accelerationIncludingGravityY = 5;
    117     buffer->data.hasAccelerationIncludingGravityY = true;
    118     buffer->data.accelerationIncludingGravityZ = 6;
    119     buffer->data.hasAccelerationIncludingGravityZ = true;
    120 
    121     buffer->data.rotationRateAlpha = 7;
    122     buffer->data.hasRotationRateAlpha = true;
    123     buffer->data.rotationRateBeta = 8;
    124     buffer->data.hasRotationRateBeta = true;
    125     buffer->data.rotationRateGamma = 9;
    126     buffer->data.hasRotationRateGamma = true;
    127 
    128     buffer->data.interval = 100;
    129     buffer->data.allAvailableSensorsAreActive = true;
    130     buffer->seqlock.WriteEnd();
    131   }
    132 
    133   void UpdateOrientation(DeviceOrientationHardwareBuffer* buffer) {
    134     buffer->seqlock.WriteBegin();
    135     buffer->data.alpha = 1;
    136     buffer->data.hasAlpha = true;
    137     buffer->data.beta = 2;
    138     buffer->data.hasBeta = true;
    139     buffer->data.gamma = 3;
    140     buffer->data.hasGamma = true;
    141     buffer->data.allAvailableSensorsAreActive = true;
    142     buffer->seqlock.WriteEnd();
    143   }
    144 
    145   base::WaitableEvent started_orientation_;
    146   base::WaitableEvent stopped_orientation_;
    147   base::WaitableEvent started_motion_;
    148   base::WaitableEvent stopped_motion_;
    149   bool sensor_data_available_;
    150 
    151  private:
    152   DISALLOW_COPY_AND_ASSIGN(FakeDataFetcher);
    153 };
    154 
    155 
    156 class DeviceInertialSensorBrowserTest : public ContentBrowserTest  {
    157  public:
    158   DeviceInertialSensorBrowserTest()
    159       : fetcher_(NULL),
    160         io_loop_finished_event_(false, false) {
    161   }
    162 
    163   virtual void SetUpOnMainThread() OVERRIDE {
    164     BrowserThread::PostTask(
    165         BrowserThread::IO, FROM_HERE,
    166         base::Bind(&DeviceInertialSensorBrowserTest::SetUpOnIOThread, this));
    167     io_loop_finished_event_.Wait();
    168   }
    169 
    170   void SetUpOnIOThread() {
    171     fetcher_ = new FakeDataFetcher();
    172     DeviceInertialSensorService::GetInstance()->
    173         SetDataFetcherForTesting(fetcher_);
    174     io_loop_finished_event_.Signal();
    175   }
    176 
    177   void DelayAndQuit(base::TimeDelta delay) {
    178     base::PlatformThread::Sleep(delay);
    179     base::MessageLoop::current()->QuitWhenIdle();
    180   }
    181 
    182   void WaitForAlertDialogAndQuitAfterDelay(base::TimeDelta delay) {
    183     ShellJavaScriptDialogManager* dialog_manager=
    184         static_cast<ShellJavaScriptDialogManager*>(
    185             shell()->GetJavaScriptDialogManager());
    186 
    187     scoped_refptr<MessageLoopRunner> runner = new MessageLoopRunner();
    188     dialog_manager->set_dialog_request_callback(
    189         base::Bind(&DeviceInertialSensorBrowserTest::DelayAndQuit, this,
    190             delay));
    191     runner->Run();
    192   }
    193 
    194   FakeDataFetcher* fetcher_;
    195 
    196  private:
    197   base::WaitableEvent io_loop_finished_event_;
    198 };
    199 
    200 
    201 IN_PROC_BROWSER_TEST_F(DeviceInertialSensorBrowserTest, OrientationTest) {
    202   // The test page will register an event handler for orientation events,
    203   // expects to get an event with fake values, then removes the event
    204   // handler and navigates to #pass.
    205   GURL test_url = GetTestUrl(
    206       "device_orientation", "device_orientation_test.html");
    207   NavigateToURLBlockUntilNavigationsComplete(shell(), test_url, 2);
    208 
    209   EXPECT_EQ("pass", shell()->web_contents()->GetLastCommittedURL().ref());
    210   fetcher_->started_orientation_.Wait();
    211   fetcher_->stopped_orientation_.Wait();
    212 }
    213 
    214 IN_PROC_BROWSER_TEST_F(DeviceInertialSensorBrowserTest, MotionTest) {
    215   // The test page will register an event handler for motion events,
    216   // expects to get an event with fake values, then removes the event
    217   // handler and navigates to #pass.
    218   GURL test_url = GetTestUrl(
    219       "device_orientation", "device_motion_test.html");
    220   NavigateToURLBlockUntilNavigationsComplete(shell(), test_url, 2);
    221 
    222   EXPECT_EQ("pass", shell()->web_contents()->GetLastCommittedURL().ref());
    223   fetcher_->started_motion_.Wait();
    224   fetcher_->stopped_motion_.Wait();
    225 }
    226 
    227 // Flaking in the android try bot. See http://crbug.com/360578.
    228 #if defined(OS_ANDROID)
    229 #define MAYBE_OrientationNullTestWithAlert DISABLED_OrientationNullTestWithAlert
    230 #else
    231 #define MAYBE_OrientationNullTestWithAlert OrientationNullTestWithAlert
    232 #endif
    233 IN_PROC_BROWSER_TEST_F(DeviceInertialSensorBrowserTest,
    234     MAYBE_OrientationNullTestWithAlert) {
    235   // The test page will register an event handler for orientation events,
    236   // expects to get an event with null values. The test raises a modal alert
    237   // dialog with a delay to test that the one-off null-event still propagates
    238   // to window after the alert is dismissed and the callback is invoked which
    239   // navigates to #pass.
    240   fetcher_->SetSensorDataAvailable(false);
    241   TestNavigationObserver same_tab_observer(shell()->web_contents(), 2);
    242 
    243   GURL test_url = GetTestUrl(
    244       "device_orientation", "device_orientation_null_test_with_alert.html");
    245   shell()->LoadURL(test_url);
    246 
    247   // TODO(timvolodine): investigate if it is possible to test this without
    248   // delay, crbug.com/360044.
    249   WaitForAlertDialogAndQuitAfterDelay(base::TimeDelta::FromMilliseconds(1000));
    250 
    251   fetcher_->started_orientation_.Wait();
    252   fetcher_->stopped_orientation_.Wait();
    253   same_tab_observer.Wait();
    254   EXPECT_EQ("pass", shell()->web_contents()->GetLastCommittedURL().ref());
    255 }
    256 
    257 // Flaking in the android try bot. See http://crbug.com/360578.
    258 #if defined(OS_ANDROID)
    259 #define MAYBE_MotionNullTestWithAlert DISABLED_MotionNullTestWithAlert
    260 #else
    261 #define MAYBE_MotionNullTestWithAlert MotionNullTestWithAlert
    262 #endif
    263 IN_PROC_BROWSER_TEST_F(DeviceInertialSensorBrowserTest,
    264     MAYBE_MotionNullTestWithAlert) {
    265   // The test page will register an event handler for motion events,
    266   // expects to get an event with null values. The test raises a modal alert
    267   // dialog with a delay to test that the one-off null-event still propagates
    268   // to window after the alert is dismissed and the callback is invoked which
    269   // navigates to #pass.
    270   fetcher_->SetSensorDataAvailable(false);
    271   TestNavigationObserver same_tab_observer(shell()->web_contents(), 2);
    272 
    273   GURL test_url = GetTestUrl(
    274       "device_orientation", "device_motion_null_test_with_alert.html");
    275   shell()->LoadURL(test_url);
    276 
    277   // TODO(timvolodine): investigate if it is possible to test this without
    278   // delay, crbug.com/360044.
    279   WaitForAlertDialogAndQuitAfterDelay(base::TimeDelta::FromMilliseconds(1000));
    280 
    281   fetcher_->started_motion_.Wait();
    282   fetcher_->stopped_motion_.Wait();
    283   same_tab_observer.Wait();
    284   EXPECT_EQ("pass", shell()->web_contents()->GetLastCommittedURL().ref());
    285 }
    286 
    287 }  //  namespace
    288 
    289 }  //  namespace content
    290