[Sensors] Improvements in shared buffer managing

device/generic_sensor/platform_sensor_provider_unittest.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 "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 
 #include "device/generic_sensor/fake_platform_sensor.h"
 #include "device/generic_sensor/fake_platform_sensor_provider.h"
 #include "device/generic_sensor/public/interfaces/sensor_provider.mojom.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace device {
 
 using mojom::SensorInitParams;
 using mojom::SensorType;
 
-namespace {
-
-uint64_t GetBufferOffset(mojom::SensorType type) {
-  return (static_cast<uint64_t>(SensorType::LAST) -
-          static_cast<uint64_t>(type)) *
-         SensorInitParams::kReadBufferSize;
-}
-
-using CreateSensorCallback =
-    base::Callback<void(scoped_refptr<PlatformSensor>)>;
-;
-
-}  // namespace
-
 class TestSensorCreateCallback {
  public:
   TestSensorCreateCallback()
       : callback_(base::Bind(&TestSensorCreateCallback::SetResult,
                              base::Unretained(this))) {}
 
   scoped_refptr<PlatformSensor> WaitForResult() {
     run_loop_.Run();
     scoped_refptr<PlatformSensor> sensor = sensor_;
     sensor_ = nullptr;
     return sensor;
   }
 
-  const CreateSensorCallback& callback() const { return callback_; }
+  const PlatformSensorProvider::CreateSensorCallback& callback() const {
+    return callback_;
+  }
 
  private:
   void SetResult(scoped_refptr<PlatformSensor> sensor) {
     sensor_ = sensor;
     run_loop_.Quit();
   }
 
-  const CreateSensorCallback callback_;
+  const PlatformSensorProvider::CreateSensorCallback callback_;
   base::RunLoop run_loop_;
   scoped_refptr<PlatformSensor> sensor_;
 };
 
 class PlatformSensorTestClient : public PlatformSensor::Client {
  public:
   PlatformSensorTestClient()
       : notification_suspended_(false),
         sensor_reading_changed_(false),
         sensor_error_(false) {}
@@ skipping 35 matching lines @@
   PlatformSensorProviderTest()
       : sensor_client_(new PlatformSensorTestClient()) {
     message_loop_.reset(new base::MessageLoopForIO);
   }
 
  protected:
   scoped_refptr<PlatformSensor> CreateSensor(
       mojom::SensorType type,
       TestSensorCreateCallback* callback) {
     FakePlatformSensorProvider::GetInstance()->CreateSensor(
-        type, SensorInitParams::kReadBufferSize, GetBufferOffset(type),
-        callback->callback());
+        type, callback->callback());
     return callback->WaitForResult();
   }
 
   std::unique_ptr<PlatformSensorTestClient> sensor_client_;
   std::unique_ptr<base::MessageLoop> message_loop_;
 };
 
 TEST_F(PlatformSensorProviderTest, CreateSensorsAndCheckType) {
   TestSensorCreateCallback callback1;
   scoped_refptr<PlatformSensor> sensor1 =
@@ skipping 41 matching lines @@
   scoped_refptr<PlatformSensor> sensor2 =
       sensor_provider->GetSensor(SensorType::GYROSCOPE);
   EXPECT_FALSE(sensor2);
 
   // Get Ambient Light sensor.
   scoped_refptr<PlatformSensor> sensor3 =
       sensor_provider->GetSensor(SensorType::AMBIENT_LIGHT);
   EXPECT_TRUE(sensor3);
 
   EXPECT_EQ(sensor1->GetType(), sensor3->GetType());
-
-  // Try to create a sensor with zero buffer and offset.
-  TestSensorCreateCallback callback4;
-  sensor_provider->CreateSensor(SensorType::GYROSCOPE, 0, 0,
-                                callback4.callback());
-  scoped_refptr<PlatformSensor> sensor4 = callback4.WaitForResult();
-  EXPECT_FALSE(sensor4);
-
-  scoped_refptr<PlatformSensor> sensor5 =
-      sensor_provider->GetSensor(SensorType::GYROSCOPE);
-  EXPECT_FALSE(sensor5);
 }
 
 TEST_F(PlatformSensorProviderTest, TestSensorLeaks) {
   PlatformSensorProvider* sensor_provider =
       FakePlatformSensorProvider::GetInstance();
 
   // Create Ambient Light sensor.
   TestSensorCreateCallback callback1;
   scoped_refptr<PlatformSensor> sensor1 =
       CreateSensor(SensorType::AMBIENT_LIGHT, &callback1);
@@ skipping 173 matching lines @@
   sensor_client_->set_notification_suspended(false);
   EXPECT_FALSE(sensor_client_->IsNotificationSuspended());
   for (const auto& client : clients)
     EXPECT_FALSE(client->IsNotificationSuspended());
 
   fake_sensor->UpdateSensor();
   EXPECT_TRUE(fake_sensor->started());
 }
 
 }  // namespace device