Remove DeviceLightEvent implementation

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"
 #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"
 #include "device/sensors/data_fetcher_shared_memory.h"
 #include "device/sensors/device_sensor_service.h"
-#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 device::DataFetcherSharedMemory {
  public:
   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;
   }
 
@@ skipping 33 matching lines @@
       } 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;
   }
 
   void Fetch(unsigned consumer_bitmask) override {
     FAIL() << "fetch should not be called";
   }
 
@@ skipping 63 matching lines @@
     buffer->data.has_alpha = true;
     buffer->data.beta = 5;
     buffer->data.has_beta = true;
     buffer->data.gamma = 6;
     buffer->data.has_gamma = true;
     buffer->data.absolute = true;
     buffer->data.all_available_sensors_are_active = 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());
@@ skipping 16 matching lines @@
         static_cast<ShellJavaScriptDialogManager*>(
             shell()->GetJavaScriptDialogManager(shell()->web_contents()));
 
     scoped_refptr<MessageLoopRunner> runner = new MessageLoopRunner();
     dialog_manager->set_dialog_request_callback(
         base::Bind(&DeviceSensorBrowserTest::DelayAndQuit,
                    base::Unretained(this), delay));
     runner->Run();
   }
 
-  void EnableExperimentalFeatures() {
-    // TODO(riju): remove when the DeviceLight feature goes stable.
-    base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
-    if (!cmd_line->HasSwitch(switches::kEnableExperimentalWebPlatformFeatures))
-      cmd_line->AppendSwitch(switches::kEnableExperimentalWebPlatformFeatures);
-  }
-
   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_;
 };
@@ skipping 16 matching lines @@
   // 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();
-  light_stopped_runloop_->Run();
-}
-
 IN_PROC_BROWSER_TEST_F(DeviceSensorBrowserTest, 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_sensors", "device_motion_test.html");
   NavigateToURLBlockUntilNavigationsComplete(shell(), test_url, 2);
 
   EXPECT_EQ("pass", shell()->web_contents()->GetLastCommittedURL().ref());
   motion_started_runloop_->Run();
   motion_stopped_runloop_->Run();
 }
 
-IN_PROC_BROWSER_TEST_F(DeviceSensorBrowserTest, LightOneOffInfintyTest) {
-  // 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());
-  light_started_runloop_->Run();
-  light_stopped_runloop_->Run();
-}
-
 IN_PROC_BROWSER_TEST_F(DeviceSensorBrowserTest, OrientationNullTest) {
   // 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());
@@ skipping 49 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