Move //content/browser/device_sensor/ into device/sensors

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/browser/device_sensors/data_fetcher_shared_memory.h"
-#include "content/browser/device_sensors/device_sensor_service.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 DataFetcherSharedMemory {
+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;
@@ skipping 10 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;
   }
 
-  bool Start(ConsumerType consumer_type, void* buffer) override {
+  bool Start(device::ConsumerType consumer_type, void* buffer) override {
     EXPECT_TRUE(buffer);
 
     switch (consumer_type) {
-      case CONSUMER_TYPE_MOTION: {
-        DeviceMotionHardwareBuffer* motion_buffer =
-            static_cast<DeviceMotionHardwareBuffer*>(buffer);
+      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 CONSUMER_TYPE_ORIENTATION: {
-        DeviceOrientationHardwareBuffer* orientation_buffer =
-            static_cast<DeviceOrientationHardwareBuffer*>(buffer);
+      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 CONSUMER_TYPE_LIGHT: {
-        DeviceLightHardwareBuffer* light_buffer =
-            static_cast<DeviceLightHardwareBuffer*>(buffer);
+      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(ConsumerType consumer_type) override {
+  bool Stop(device::ConsumerType consumer_type) override {
     switch (consumer_type) {
-      case CONSUMER_TYPE_MOTION:
+      case device::CONSUMER_TYPE_MOTION:
         BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                                 motion_stopped_callback_);
         break;
-      case CONSUMER_TYPE_ORIENTATION:
+      case device::CONSUMER_TYPE_ORIENTATION:
         BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                                 orientation_stopped_callback_);
         break;
-      case CONSUMER_TYPE_LIGHT:
+      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";
   }
 
   FetcherType GetType() const override { return FETCHER_TYPE_DEFAULT; }
 
   void SetSensorDataAvailable(bool available) {
     sensor_data_available_ = available;
   }
 
-  void SetMotionBufferReady(DeviceMotionHardwareBuffer* buffer) {
+  void SetMotionBufferReady(device::DeviceMotionHardwareBuffer* buffer) {
     buffer->seqlock.WriteBegin();
     buffer->data.allAvailableSensorsAreActive = true;
     buffer->seqlock.WriteEnd();
   }
 
-  void SetOrientationBufferReady(DeviceOrientationHardwareBuffer* buffer) {
+  void SetOrientationBufferReady(
+      device::DeviceOrientationHardwareBuffer* buffer) {
     buffer->seqlock.WriteBegin();
     buffer->data.allAvailableSensorsAreActive = true;
     buffer->seqlock.WriteEnd();
   }
 
-  void UpdateMotion(DeviceMotionHardwareBuffer* buffer) {
+  void UpdateMotion(device::DeviceMotionHardwareBuffer* buffer) {
     buffer->seqlock.WriteBegin();
     buffer->data.accelerationX = 1;
     buffer->data.hasAccelerationX = true;
     buffer->data.accelerationY = 2;
     buffer->data.hasAccelerationY = true;
     buffer->data.accelerationZ = 3;
     buffer->data.hasAccelerationZ = true;
 
     buffer->data.accelerationIncludingGravityX = 4;
     buffer->data.hasAccelerationIncludingGravityX = true;
     buffer->data.accelerationIncludingGravityY = 5;
     buffer->data.hasAccelerationIncludingGravityY = true;
     buffer->data.accelerationIncludingGravityZ = 6;
     buffer->data.hasAccelerationIncludingGravityZ = true;
 
     buffer->data.rotationRateAlpha = 7;
     buffer->data.hasRotationRateAlpha = true;
     buffer->data.rotationRateBeta = 8;
     buffer->data.hasRotationRateBeta = true;
     buffer->data.rotationRateGamma = 9;
     buffer->data.hasRotationRateGamma = true;
 
     buffer->data.interval = 100;
     buffer->data.allAvailableSensorsAreActive = true;
     buffer->seqlock.WriteEnd();
   }
 
-  void UpdateOrientation(DeviceOrientationHardwareBuffer* buffer) {
+  void UpdateOrientation(device::DeviceOrientationHardwareBuffer* buffer) {
     buffer->seqlock.WriteBegin();
     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) {
+  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 light_started_callback_;
   base::Closure motion_stopped_callback_;
@@ skipping 37 matching lines @@
   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());
-    DeviceSensorService::GetInstance()->SetDataFetcherForTesting(fetcher_);
+    device::DeviceSensorService::GetInstance()->SetDataFetcherForTesting(
+        fetcher_);
   }
 
   void SetUpOnIOThread() {
     SetUpFetcher();
     io_loop_finished_event_.Signal();
   }
 
   void DelayAndQuit(base::TimeDelta delay) {
     base::PlatformThread::Sleep(delay);
     base::MessageLoop::current()->QuitWhenIdle();
@@ skipping 133 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