[sensors] Android platform adaptation for Generic Sensor API

device/generic_sensor/platform_sensor_provider_android.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/platform_sensor_provider.h"
+
+#include "base/android/context_utils.h"
+#include "base/android/scoped_java_ref.h"
+#include "base/memory/singleton.h"
+#include "device/generic_sensor/platform_sensor_android.h"
+#include "jni/PlatformSensorProvider_jni.h"
+
+using base::android::AttachCurrentThread;
+using base::android::ScopedJavaLocalRef;
+
+namespace device {
+
+class PlatformSensorProviderAndroid : public PlatformSensorProvider {
+ public:
+  PlatformSensorProviderAndroid();
+  ~PlatformSensorProviderAndroid() override;
+
+  static PlatformSensorProviderAndroid* GetInstance();
+
+ protected:
+  scoped_refptr<PlatformSensor> CreateSensorInternal(
+      mojom::SensorType type,
+      mojo::ScopedSharedBufferMapping mapping,
+      uint64_t buffer_size) override;
+
+ private:
+  // Java object org.chromium.device.sensors.PlatformSensorProvider
+  base::android::ScopedJavaGlobalRef<jobject> j_object_;
+
+  DISALLOW_COPY_AND_ASSIGN(PlatformSensorProviderAndroid);
+};
+
+// static
+PlatformSensorProvider* PlatformSensorProvider::GetInstance() {
+  return PlatformSensorProviderAndroid::GetInstance();

[timvolodine, 2016/09/06 17:44:38]

Looks a bit awkward, having two singletons.. It would arguably be better to have
one singleton instance somewhere owning platform provider instances, that way
would also be easier to inject providers for testing e.g. in browsertests. I
guess the refactoring can be done in a separate CL though.

[shalamov, 2016/09/07 13:53:42]

I couldn't figure out how to return singleton from
PlatformSensorProvider::GetInstance(), since Singleton class defines static
Type* get(); as private. We still have one Singleton, per platform, it just
needs to be returned by concrete PlatformSensorProviderAndroid.

+}
+
+// static
+PlatformSensorProviderAndroid* PlatformSensorProviderAndroid::GetInstance() {
+  return base::Singleton<
+      PlatformSensorProviderAndroid,
+      base::LeakySingletonTraits<PlatformSensorProviderAndroid>>::get();
+}
+
+PlatformSensorProviderAndroid::PlatformSensorProviderAndroid() {
+  JNIEnv* env = AttachCurrentThread();
+  j_object_.Reset(Java_PlatformSensorProvider_create(
+      env, base::android::GetApplicationContext()));
+}
+
+PlatformSensorProviderAndroid::~PlatformSensorProviderAndroid() = default;
+
+scoped_refptr<PlatformSensor>
+PlatformSensorProviderAndroid::CreateSensorInternal(
+    mojom::SensorType type,
+    mojo::ScopedSharedBufferMapping mapping,
+    uint64_t buffer_size) {
+  JNIEnv* env = AttachCurrentThread();
+  ScopedJavaLocalRef<jobject> sensor = Java_PlatformSensorProvider_createSensor(
+      env, j_object_.obj(), static_cast<jint>(type));
+
+  if (!sensor.obj())
+    return nullptr;
+
+  return new PlatformSensorAndroid(type, std::move(mapping), buffer_size, this,
+                                   sensor);
+}
+
+}  // namespace device