Ensure complete end-to-end browsertest coverage for absolute device orientation.

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/public/browser/browser_thread.h"
@@ skipping 39 matching lines @@
   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;
   }
 
+  void SetOrientationAbsoluteStartedCallback(
+      base::Closure orientation_absolute_started_callback) {
+    orientation_absolute_started_callback_ =
+        orientation_absolute_started_callback;
+  }
+
+  void SetOrientationAbsoluteStoppedCallback(
+      base::Closure orientation_absolute_stopped_callback) {
+    orientation_absolute_stopped_callback_ =
+        orientation_absolute_stopped_callback;
+  }
+
   bool Start(device::ConsumerType consumer_type, void* buffer) override {
     EXPECT_TRUE(buffer);
 
     switch (consumer_type) {
       case device::CONSUMER_TYPE_MOTION: {
         device::DeviceMotionHardwareBuffer* motion_buffer =
             static_cast<device::DeviceMotionHardwareBuffer*>(buffer);
         if (sensor_data_available_)
           UpdateMotion(motion_buffer);
         SetMotionBufferReady(motion_buffer);
         BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                                 motion_started_callback_);
       } break;
       case device::CONSUMER_TYPE_ORIENTATION: {
         device::DeviceOrientationHardwareBuffer* orientation_buffer =
             static_cast<device::DeviceOrientationHardwareBuffer*>(buffer);
         if (sensor_data_available_)
           UpdateOrientation(orientation_buffer);
         SetOrientationBufferReady(orientation_buffer);
         BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                                 orientation_started_callback_);
       } break;
+      case device::CONSUMER_TYPE_ORIENTATION_ABSOLUTE: {
+        device::DeviceOrientationHardwareBuffer* orientation_buffer =
+            static_cast<device::DeviceOrientationHardwareBuffer*>(buffer);
+        if (sensor_data_available_)
+          UpdateOrientationAbsolute(orientation_buffer);
+        SetOrientationBufferReady(orientation_buffer);
+        BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                                orientation_absolute_started_callback_);
+      } break;
       case device::CONSUMER_TYPE_LIGHT: {
         device::DeviceLightHardwareBuffer* light_buffer =
             static_cast<device::DeviceLightHardwareBuffer*>(buffer);
         UpdateLight(light_buffer,
                     sensor_data_available_
                         ? 100
                         : std::numeric_limits<double>::infinity());
         BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                                 light_started_callback_);
       } break;
       default:
         return false;
     }
     return true;
   }
 
   bool Stop(device::ConsumerType consumer_type) override {
     switch (consumer_type) {
       case device::CONSUMER_TYPE_MOTION:
         BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                                 motion_stopped_callback_);
         break;
       case device::CONSUMER_TYPE_ORIENTATION:
         BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                                 orientation_stopped_callback_);
         break;
+      case device::CONSUMER_TYPE_ORIENTATION_ABSOLUTE:
+        BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                                orientation_absolute_stopped_callback_);
+        break;
       case device::CONSUMER_TYPE_LIGHT:
         BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                                 light_stopped_callback_);
         break;
       default:
         return false;
     }
     return true;
   }
 
@@ skipping 53 matching lines @@
     buffer->data.alpha = 1;
     buffer->data.hasAlpha = true;
     buffer->data.beta = 2;
     buffer->data.hasBeta = true;
     buffer->data.gamma = 3;
     buffer->data.hasGamma = true;
     buffer->data.allAvailableSensorsAreActive = true;
     buffer->seqlock.WriteEnd();
   }
 
+  void UpdateOrientationAbsolute(
+      device::DeviceOrientationHardwareBuffer* buffer) {
+    buffer->seqlock.WriteBegin();
+    buffer->data.alpha = 4;
+    buffer->data.hasAlpha = true;
+    buffer->data.beta = 5;
+    buffer->data.hasBeta = true;
+    buffer->data.gamma = 6;
+    buffer->data.hasGamma = true;
+    buffer->data.absolute = true;
+    buffer->data.allAvailableSensorsAreActive = true;
+    buffer->seqlock.WriteEnd();
+  }
+
   void UpdateLight(device::DeviceLightHardwareBuffer* buffer, double lux) {
     buffer->seqlock.WriteBegin();
     buffer->data.value = lux;
     buffer->seqlock.WriteEnd();
   }
 
   // The below callbacks should be run on the UI thread.
   base::Closure motion_started_callback_;
   base::Closure orientation_started_callback_;
+  base::Closure orientation_absolute_started_callback_;
   base::Closure light_started_callback_;
   base::Closure motion_stopped_callback_;
   base::Closure orientation_stopped_callback_;
+  base::Closure orientation_absolute_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 {
     // Initialize the RunLoops now that the main thread has been created.
     light_started_runloop_.reset(new base::RunLoop());
     light_stopped_runloop_.reset(new base::RunLoop());
     motion_started_runloop_.reset(new base::RunLoop());
     motion_stopped_runloop_.reset(new base::RunLoop());
     orientation_started_runloop_.reset(new base::RunLoop());
     orientation_stopped_runloop_.reset(new base::RunLoop());
+    orientation_absolute_started_runloop_.reset(new base::RunLoop());
+    orientation_absolute_stopped_runloop_.reset(new base::RunLoop());
 #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();
     fetcher_->SetLightStartedCallback(light_started_runloop_->QuitClosure());
     fetcher_->SetLightStoppedCallback(light_stopped_runloop_->QuitClosure());
     fetcher_->SetMotionStartedCallback(motion_started_runloop_->QuitClosure());
     fetcher_->SetMotionStoppedCallback(motion_stopped_runloop_->QuitClosure());
     fetcher_->SetOrientationStartedCallback(
         orientation_started_runloop_->QuitClosure());
     fetcher_->SetOrientationStoppedCallback(
         orientation_stopped_runloop_->QuitClosure());
+    fetcher_->SetOrientationAbsoluteStartedCallback(
+        orientation_absolute_started_runloop_->QuitClosure());
+    fetcher_->SetOrientationAbsoluteStoppedCallback(
+        orientation_absolute_stopped_runloop_->QuitClosure());
     device::DeviceSensorService::GetInstance()->SetDataFetcherForTesting(
         fetcher_);
   }
 
   void SetUpOnIOThread() {
     SetUpFetcher();
     io_loop_finished_event_.Signal();
   }
 
   void DelayAndQuit(base::TimeDelta delay) {
@@ skipping 23 matching lines @@
   FakeDataFetcher* fetcher_;
 
   // NOTE: These can only be initialized once the main thread has been created
   // and so must be pointers instead of plain objects.
   std::unique_ptr<base::RunLoop> light_started_runloop_;
   std::unique_ptr<base::RunLoop> light_stopped_runloop_;
   std::unique_ptr<base::RunLoop> motion_started_runloop_;
   std::unique_ptr<base::RunLoop> motion_stopped_runloop_;
   std::unique_ptr<base::RunLoop> orientation_started_runloop_;
   std::unique_ptr<base::RunLoop> orientation_stopped_runloop_;
+  std::unique_ptr<base::RunLoop> orientation_absolute_started_runloop_;
+  std::unique_ptr<base::RunLoop> orientation_absolute_stopped_runloop_;
 
  private:
   base::WaitableEvent io_loop_finished_event_;
 };
 
 IN_PROC_BROWSER_TEST_F(DeviceSensorBrowserTest, OrientationTest) {
   // 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());
   orientation_started_runloop_->Run();
   orientation_stopped_runloop_->Run();
 }
 
+IN_PROC_BROWSER_TEST_F(DeviceSensorBrowserTest, OrientationAbsoluteTest) {
+  // The test page will register an event handler for absolute 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_absolute_test.html");
+  NavigateToURLBlockUntilNavigationsComplete(shell(), test_url, 2);
+
+  EXPECT_EQ("pass", shell()->web_contents()->GetLastCommittedURL().ref());
+  orientation_absolute_started_runloop_->Run();
+  orientation_absolute_stopped_runloop_->Run();
+}
+
 IN_PROC_BROWSER_TEST_F(DeviceSensorBrowserTest, LightTest) {
   // 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());
   light_started_runloop_->Run();
@@ skipping 34 matching lines @@
   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());
   orientation_started_runloop_->Run();
   orientation_stopped_runloop_->Run();
 }
 
+IN_PROC_BROWSER_TEST_F(DeviceSensorBrowserTest, OrientationAbsoluteNullTest) {
+  // The test page registers an event handler for absolute 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_absolute_null_test.html");
+  NavigateToURLBlockUntilNavigationsComplete(shell(), test_url, 2);
+
+  EXPECT_EQ("pass", shell()->web_contents()->GetLastCommittedURL().ref());
+  orientation_absolute_started_runloop_->Run();
+  orientation_absolute_stopped_runloop_->Run();
+}
+
 IN_PROC_BROWSER_TEST_F(DeviceSensorBrowserTest, MotionNullTest) {
   // 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());
   motion_started_runloop_->Run();
@@ skipping 21 matching lines @@
   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