[DeviceLight] Browser+java part

content/browser/device_sensors/device_inertial_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/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "content/browser/device_sensors/data_fetcher_shared_memory.h"
 #include "content/browser/device_sensors/device_inertial_sensor_service.h"
+#include "content/common/device_sensors/device_light_hardware_buffer.h"
 #include "content/common/device_sensors/device_motion_hardware_buffer.h"
 #include "content/common/device_sensors/device_orientation_hardware_buffer.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
+#include "content/public/common/content_switches.h"
 #include "content/public/test/content_browser_test.h"
 #include "content/public/test/content_browser_test_utils.h"
 #include "content/public/test/test_navigation_observer.h"
 #include "content/public/test/test_utils.h"
 #include "content/shell/browser/shell.h"
 #include "content/shell/browser/shell_javascript_dialog_manager.h"
 
 namespace content {
 
 namespace {
 
 class FakeDataFetcher : public DataFetcherSharedMemory {
  public:
   FakeDataFetcher()
       : started_orientation_(false, false),
         stopped_orientation_(false, false),
         started_motion_(false, false),
         stopped_motion_(false, false),
-        sensor_data_available_(true) {
-  }
+        started_light_(false, false),
+        stopped_light_(false, false),
+        sensor_data_available_(true) {}
   virtual ~FakeDataFetcher() { }
 
   virtual 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();
         }
         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();
         }
         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();
+        }
+        break;
       default:
         return false;
     }
     return true;
   }
 
   virtual bool Stop(ConsumerType consumer_type) OVERRIDE {
     switch (consumer_type) {
       case CONSUMER_TYPE_MOTION:
         stopped_motion_.Signal();
         break;
       case CONSUMER_TYPE_ORIENTATION:
         stopped_orientation_.Signal();
         break;
+      case CONSUMER_TYPE_LIGHT:
+        stopped_light_.Signal();
+        break;
       default:
         return false;
     }
     return true;
   }
 
   virtual void Fetch(unsigned consumer_bitmask) OVERRIDE {
     FAIL() << "fetch should not be called";
   }
 
@@ skipping 50 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 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_;
   bool sensor_data_available_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FakeDataFetcher);
 };
 
 
 class DeviceInertialSensorBrowserTest : public ContentBrowserTest  {
  public:
   DeviceInertialSensorBrowserTest()
@@ skipping 31 matching lines @@
             delay));
     runner->Run();
   }
 
   FakeDataFetcher* fetcher_;
 
  private:
   base::WaitableEvent io_loop_finished_event_;
 };
 
-
 IN_PROC_BROWSER_TEST_F(DeviceInertialSensorBrowserTest, 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_orientation", "device_orientation_test.html");
+  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();
 }
 
+IN_PROC_BROWSER_TEST_F(DeviceInertialSensorBrowserTest, 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.
+  GURL test_url = GetTestUrl("device_sensors", "device_light_test.html");
+
+  // TODO(riju): remove command line args when the feature goes stable.
+  if (!CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kEnableExperimentalWebPlatformFeatures)) {
+    CommandLine::ForCurrentProcess()->AppendSwitch(
+        switches::kEnableExperimentalWebPlatformFeatures);
+  }
+
+  NavigateToURLBlockUntilNavigationsComplete(shell(), test_url, 2);
+
+  EXPECT_EQ("pass", shell()->web_contents()->GetLastCommittedURL().ref());
+  fetcher_->started_light_.Wait();
+  fetcher_->stopped_light_.Wait();
+}
+
 IN_PROC_BROWSER_TEST_F(DeviceInertialSensorBrowserTest, MotionTest) {
   // 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_orientation", "device_motion_test.html");
+  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();
 }
 
+IN_PROC_BROWSER_TEST_F(DeviceInertialSensorBrowserTest, LightNullTest) {
+  // The test page will register an event handler for light events,
+  // expects to get an event with null(Inf) values. This tests that the one-off

[timvolodine, 2014/09/10 13:47:25]

you seem to use null events and inf values interchangeably this is confusing,
maybe use "one-off infinity event" as a generic term everywhere.

[riju_, 2014/09/22 08:22:21]

Done.

+  // null-event still propagates to window after the alert is dismissed and
+  // the callback is invoked which navigates to #pass.
+  fetcher_->SetSensorDataAvailable(false);
+
+  // TODO(riju): remove command line args when the feature goes stable.
+  if (!CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kEnableExperimentalWebPlatformFeatures)) {
+    CommandLine::ForCurrentProcess()->AppendSwitch(
+        switches::kEnableExperimentalWebPlatformFeatures);
+  }
+
+  TestNavigationObserver same_tab_observer(shell()->web_contents(), 2);
+
+  GURL test_url = GetTestUrl("device_sensors", "device_light_null_test.html");
+  shell()->LoadURL(test_url);
+
+  WaitForAlertDialogAndQuitAfterDelay(base::TimeDelta::FromMilliseconds(1000));
+
+  fetcher_->started_light_.Wait();
+  fetcher_->stopped_light_.Wait();
+  same_tab_observer.Wait();
+  EXPECT_EQ("pass", shell()->web_contents()->GetLastCommittedURL().ref());
+}
+
 // Flaking in the android try bot. See http://crbug.com/360578.
 #if defined(OS_ANDROID)
 #define MAYBE_OrientationNullTestWithAlert DISABLED_OrientationNullTestWithAlert
 #else
 #define MAYBE_OrientationNullTestWithAlert OrientationNullTestWithAlert
 #endif
 IN_PROC_BROWSER_TEST_F(DeviceInertialSensorBrowserTest,
     MAYBE_OrientationNullTestWithAlert) {
   // The test page will register an event handler for orientation events,
   // expects to get an event with null values. The test raises a modal alert
   // dialog with a delay to test that the one-off null-event still propagates
   // to window after the alert is dismissed and the callback is invoked which
   // navigates to #pass.
   fetcher_->SetSensorDataAvailable(false);
   TestNavigationObserver same_tab_observer(shell()->web_contents(), 2);
 
-  GURL test_url = GetTestUrl(
-      "device_orientation", "device_orientation_null_test_with_alert.html");
+  GURL test_url = GetTestUrl("device_sensors",
+                             "device_orientation_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(1000));
 
   fetcher_->started_orientation_.Wait();
   fetcher_->stopped_orientation_.Wait();
   same_tab_observer.Wait();
   EXPECT_EQ("pass", shell()->web_contents()->GetLastCommittedURL().ref());
 }
 
 // Flaking in the android try bot. See http://crbug.com/360578.
 #if defined(OS_ANDROID)
 #define MAYBE_MotionNullTestWithAlert DISABLED_MotionNullTestWithAlert
 #else
 #define MAYBE_MotionNullTestWithAlert MotionNullTestWithAlert
 #endif
 IN_PROC_BROWSER_TEST_F(DeviceInertialSensorBrowserTest,
     MAYBE_MotionNullTestWithAlert) {
   // The test page will register an event handler for motion events,
   // expects to get an event with null values. The test raises a modal alert
   // dialog with a delay to test that the one-off null-event still propagates
   // to window after the alert is dismissed and the callback is invoked which
   // navigates to #pass.
   fetcher_->SetSensorDataAvailable(false);
   TestNavigationObserver same_tab_observer(shell()->web_contents(), 2);
 
-  GURL test_url = GetTestUrl(
-      "device_orientation", "device_motion_null_test_with_alert.html");
+  GURL test_url =
+      GetTestUrl("device_sensors", "device_motion_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(1000));
 
   fetcher_->started_motion_.Wait();
   fetcher_->stopped_motion_.Wait();
   same_tab_observer.Wait();
   EXPECT_EQ("pass", shell()->web_contents()->GetLastCommittedURL().ref());
 }
 
 }  //  namespace
 
 }  //  namespace content