Reland: Refactor DeviceMotionEventPump to use //device/generic_sensor instead of //device/sensors

device/generic_sensor/sensor_provider_impl.cc

 // Copyright 2016 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 "device/generic_sensor/sensor_provider_impl.h"
 
 #include <utility>
 
+#include "base/feature_list.h"
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "device/generic_sensor/platform_sensor_provider.h"
 #include "device/generic_sensor/sensor_impl.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
+#include "services/device/public/cpp/device_features.h"
 
 namespace device {
 
 namespace {
 
 void RunCallback(mojom::SensorInitParamsPtr init_params,
                  mojom::SensorClientRequest client,
                  SensorProviderImpl::GetSensorCallback callback) {
   std::move(callback).Run(std::move(init_params), std::move(client));
 }
@@ skipping 23 matching lines @@
 SensorProviderImpl::SensorProviderImpl(PlatformSensorProvider* provider)
     : provider_(provider), weak_ptr_factory_(this) {
   DCHECK(provider_);
 }
 
 SensorProviderImpl::~SensorProviderImpl() {}
 
 void SensorProviderImpl::GetSensor(mojom::SensorType type,
                                    mojom::SensorRequest sensor_request,
                                    GetSensorCallback callback) {
+  // For sensors that are used by DeviceMotionEvent, don't check the
+  // features::kGenericSensor flag.

[timvolodine, 2017/06/07 20:37:36]

nit: maybe add a TODO to remove when and if generic sensors is live?

[juncai, 2017/06/07 23:05:08]

Done.

+  if (!base::FeatureList::IsEnabled(features::kGenericSensor) &&
+      !(type == mojom::SensorType::ACCELEROMETER ||
+        type == mojom::SensorType::LINEAR_ACCELERATION ||
+        type == mojom::SensorType::GYROSCOPE)) {
+    NotifySensorCreated(nullptr, nullptr, std::move(callback));
+    return;
+  }
+
   auto cloned_handle = provider_->CloneSharedBufferHandle();
   if (!cloned_handle.is_valid()) {
     NotifySensorCreated(nullptr, nullptr, std::move(callback));
     return;
   }
 
   scoped_refptr<PlatformSensor> sensor = provider_->GetSensor(type);
   if (!sensor) {
     PlatformSensorProviderBase::CreateSensorCallback cb = base::Bind(
         &SensorProviderImpl::SensorCreated, weak_ptr_factory_.GetWeakPtr(),
@@ skipping 35 matching lines @@
   init_params->minimum_frequency = sensor->GetMinimumSupportedFrequency();
   DCHECK_GT(init_params->minimum_frequency, 0.0);
 
   NotifySensorCreated(std::move(init_params), sensor_impl->GetClient(),
                       std::move(callback));
 
   mojo::MakeStrongBinding(std::move(sensor_impl), std::move(sensor_request));
 }
 
 }  // namespace device