Refactor GeofencingManager to have one instance per StoragePartition.

content/browser/geofencing/geofencing_service_unittest.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 "content/browser/geofencing/geofencing_provider.h"
+#include "content/browser/geofencing/geofencing_registration_delegate.h"
+#include "content/browser/geofencing/geofencing_service.h"
+#include "content/public/test/test_browser_thread_bundle.h"
+#include "content/public/test/test_utils.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/WebKit/public/platform/WebCircularGeofencingRegion.h"
+
+using blink::WebCircularGeofencingRegion;
+
+namespace {
+
+bool RegionsMatch(const WebCircularGeofencingRegion& expected,
+                  const WebCircularGeofencingRegion& arg) {
+  return testing::Matches(expected.latitude)(arg.latitude) &&
+         testing::Matches(expected.longitude)(arg.longitude) &&
+         testing::Matches(expected.radius)(arg.radius);
+}
+
+}  // namespace
+
+namespace content {
+
+class MockGeofencingRegistrationDelegate
+    : public GeofencingRegistrationDelegate {
+ public:
+  MOCK_METHOD2(RegistrationFinished,
+               void(int64 geofencing_registration_id, GeofencingStatus status));
+};
+
+class MockGeofencingProvider : public GeofencingProvider {
+ public:
+  MOCK_METHOD3(RegisterRegion,
+               void(int64 geofencing_registration_id,
+                    const blink::WebCircularGeofencingRegion& region,
+                    const StatusCallback& callback));
+  MOCK_METHOD1(UnregisterRegion, void(int64 geofencing_registration_id));
+};
+
+ACTION_P(QuitRunner, runner) {
+  runner->Quit();
+}
+
+ACTION_P(SaveRegistrationId, geofencing_registration_id) {
+  *geofencing_registration_id = arg0;
+}
+
+ACTION_P(SaveStatusCallback, callback) {
+  *callback = arg2;
+}
+
+MATCHER_P(WebCircularGeofencingRegionEq, expected, "") {
+  return RegionsMatch(expected, arg);
+}
+
+class GeofencingServiceTest : public testing::Test {
+ public:
+  GeofencingServiceTest() : service_(nullptr) {
+    test_region_.latitude = 37.421999;
+    test_region_.longitude = -122.084015;
+    test_region_.radius = 100;
+  }
+
+  virtual void SetUp() { service_ = new GeofencingServiceImpl(); }
+
+  virtual void TearDown() { delete service_; }
+
+  void SetProviderForTests() {
+    provider_ = new MockGeofencingProvider();
+    service_->SetProviderForTesting(make_scoped_ptr(provider_));
+  }
+
+  int RegistrationCount() { return service_->RegistrationCountForTesting(); }
+
+  int64 RegisterRegionSync(const WebCircularGeofencingRegion& region,
+                           GeofencingStatus provider_status) {
+    scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner());
+
+    // The registration ID that is passed to the provider.
+    int64 provider_registration_id = -1;
+    // The callback that is passed to the provider.
+    GeofencingProvider::StatusCallback callback;
+
+    EXPECT_CALL(
+        *provider_,
+        RegisterRegion(
+            testing::_, WebCircularGeofencingRegionEq(region), testing::_))
+        .WillOnce(testing::DoAll(SaveRegistrationId(&provider_registration_id),
+                                 SaveStatusCallback(&callback)));
+
+    int64 geofencing_registration_id =
+        service_->RegisterRegion(region, &delegate_);
+
+    // Service should have synchronously called the provider.
+    CHECK(!callback.is_null());
+    CHECK(provider_registration_id == geofencing_registration_id);
+
+    // Finish up registration by calling the callback and waiting for the
+    // delegate to be called.
+    EXPECT_CALL(
+        delegate_,
+        RegistrationFinished(geofencing_registration_id, provider_status))
+        .WillOnce(QuitRunner(runner));
+    callback.Run(provider_status);
+    runner->Run();
+    return geofencing_registration_id;
+  }
+
+ protected:
+  TestBrowserThreadBundle threads_;
+  GeofencingServiceImpl* service_;
+  MockGeofencingProvider* provider_;
+  MockGeofencingRegistrationDelegate delegate_;
+
+  WebCircularGeofencingRegion test_region_;
+};
+
+TEST_F(GeofencingServiceTest, RegisterRegion_NoProvider) {
+  scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner());
+  int64 geofencing_registration_id =
+      service_->RegisterRegion(test_region_, &delegate_);
+  EXPECT_CALL(delegate_,
+              RegistrationFinished(
+                  geofencing_registration_id,
+                  GEOFENCING_STATUS_OPERATION_FAILED_SERVICE_NOT_AVAILABLE))
+      .WillOnce(QuitRunner(runner));
+  runner->Run();
+  EXPECT_EQ(0, RegistrationCount());
+}
+
+TEST_F(GeofencingServiceTest, RegisterRegion_FailsInProvider) {
+  SetProviderForTests();
+  RegisterRegionSync(test_region_, GEOFENCING_STATUS_ERROR);
+  EXPECT_EQ(0, RegistrationCount());
+}
+
+TEST_F(GeofencingServiceTest, RegisterRegion_SucceedsInProvider) {
+  SetProviderForTests();
+  RegisterRegionSync(test_region_, GEOFENCING_STATUS_OK);
+  EXPECT_EQ(1, RegistrationCount());
+}
+
+TEST_F(GeofencingServiceTest, UnregisterRegion_AfterRegistration) {
+  SetProviderForTests();
+  int geofencing_registration_id =
+      RegisterRegionSync(test_region_, GEOFENCING_STATUS_OK);
+  EXPECT_EQ(1, RegistrationCount());
+
+  EXPECT_CALL(*provider_, UnregisterRegion(geofencing_registration_id));
+  service_->UnregisterRegion(geofencing_registration_id);
+  EXPECT_EQ(0, RegistrationCount());
+}
+
+TEST_F(GeofencingServiceTest, UnregisterRegion_DuringSuccesfullRegistration) {
+  SetProviderForTests();
+  scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner());
+
+  // The callback that is passed to the provider.
+  GeofencingProvider::StatusCallback callback;
+
+  EXPECT_CALL(
+      *provider_,
+      RegisterRegion(
+          testing::_, WebCircularGeofencingRegionEq(test_region_), testing::_))
+      .WillOnce(SaveStatusCallback(&callback));
+
+  int64 geofencing_registration_id =
+      service_->RegisterRegion(test_region_, &delegate_);
+
+  // Service should have synchronously called the provider.
+  CHECK(!callback.is_null());
+
+  // Call unregister before registration is finished.
+  service_->UnregisterRegion(geofencing_registration_id);
+
+  // Finish up registration by calling the callback and waiting for the
+  // provider to be called. The delegate should not be called in this case.
+  EXPECT_CALL(delegate_, RegistrationFinished(testing::_, testing::_)).Times(0);
+  EXPECT_CALL(*provider_, UnregisterRegion(geofencing_registration_id))
+      .WillOnce(QuitRunner(runner));
+  callback.Run(GEOFENCING_STATUS_OK);
+  runner->Run();
+  EXPECT_EQ(0, RegistrationCount());
+}
+
+}  // namespace content