Add service unittest for WakeLockServiceImpl.

services/device/wake_lock/wake_lock_service_impl_unittest.cc

Index: services/device/wake_lock/wake_lock_service_impl_unittest.cc
diff --git a/services/device/wake_lock/wake_lock_service_impl_unittest.cc b/services/device/wake_lock/wake_lock_service_impl_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..c183c475faf85b720704ce88ffbd689ccaa8a6ab
--- /dev/null
+++ b/services/device/wake_lock/wake_lock_service_impl_unittest.cc
@@ -0,0 +1,205 @@
+// Copyright 2017 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/run_loop.h"
+#include "device/wake_lock/public/interfaces/wake_lock_context.mojom.h"
+#include "device/wake_lock/public/interfaces/wake_lock_provider.mojom.h"
+#include "device/wake_lock/public/interfaces/wake_lock_service.mojom.h"
+#include "device/wake_lock/wake_lock_provider.h"
+#include "mojo/public/cpp/bindings/interface_ptr.h"
+#include "services/device/device_service_test_base.h"
+#include "services/device/public/interfaces/constants.mojom.h"
+
+namespace device {
+
+namespace {
+
+class WakeLockServiceImplTest : public DeviceServiceTestBase {
+ public:
+  WakeLockServiceImplTest() = default;
+  ~WakeLockServiceImplTest() override = default;
+
+ protected:
+  void SetUp() override {
+    DeviceServiceTestBase::SetUp();
+    connector()->BindInterface(mojom::kServiceName, &wake_lock_provider_);
+
+    WakeLockProvider::is_in_service_unittest_ = true;
+    wake_lock_provider_->GetWakeLockWithoutContext(
+        device::mojom::WakeLockType::PreventAppSuspension,
+        device::mojom::WakeLockReason::ReasonOther, "WakeLockServiceImplTest",
+        mojo::MakeRequest(&wake_lock_));
+  }
+
+  void OnHasWakeLock(base::Closure quit_closure, bool has_wakelock) {
+    has_wakelock_ = has_wakelock;
+    quit_closure.Run();
+  }
+
+  bool HasWakeLock() {
+    has_wakelock_ = false;
+
+    base::RunLoop run_loop;
+    wake_lock_->HasWakeLockForTests(
+        base::Bind(&WakeLockServiceImplTest::OnHasWakeLock,
+                   base::Unretained(this), run_loop.QuitClosure()));
+    run_loop.Run();
+
+    return has_wakelock_;
+  }
+
+  bool has_wakelock_;
+
+  mojom::WakeLockProviderPtr wake_lock_provider_;
+  mojom::WakeLockServicePtr wake_lock_;
+
+  DISALLOW_COPY_AND_ASSIGN(WakeLockServiceImplTest);
+};
+
+// Request a wake lock, then cancel.
+TEST_F(WakeLockServiceImplTest, RequestThenCancel) {
+  EXPECT_FALSE(HasWakeLock());
+
+  wake_lock_->RequestWakeLock();
+  EXPECT_TRUE(HasWakeLock());
+
+  wake_lock_->CancelWakeLock();
+  EXPECT_FALSE(HasWakeLock());
+}
+
+// Cancel a wake lock first, which should have no effect.
+TEST_F(WakeLockServiceImplTest, CancelThenRequest) {
+  EXPECT_FALSE(HasWakeLock());
+
+  wake_lock_->CancelWakeLock();
+  EXPECT_FALSE(HasWakeLock());
+
+  wake_lock_->RequestWakeLock();
+  EXPECT_TRUE(HasWakeLock());
+
+  wake_lock_->CancelWakeLock();
+  EXPECT_FALSE(HasWakeLock());
+}
+
+// Send multiple requests, which should be coalesced as one request.
+TEST_F(WakeLockServiceImplTest, MultipleRequests) {
+  EXPECT_FALSE(HasWakeLock());
+
+  wake_lock_->RequestWakeLock();
+  wake_lock_->RequestWakeLock();
+  wake_lock_->RequestWakeLock();
+  EXPECT_TRUE(HasWakeLock());
+
+  wake_lock_->CancelWakeLock();
+  EXPECT_FALSE(HasWakeLock());
+}
+
+// WakeLockProvider connection broken doesn't affect WakeLockService.
+TEST_F(WakeLockServiceImplTest, OnWakeLockProviderConnectionError) {
+  EXPECT_FALSE(HasWakeLock());
+
+  wake_lock_->RequestWakeLock();
+  EXPECT_TRUE(HasWakeLock());
+
+  wake_lock_provider_.reset();
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_TRUE(HasWakeLock());
+  wake_lock_->CancelWakeLock();
+  EXPECT_FALSE(HasWakeLock());
+}
+
+// One WakeLockService instance can serve multiple clients at same time.
+TEST_F(WakeLockServiceImplTest, MultipleClients) {
+  EXPECT_FALSE(HasWakeLock());
+
+  mojom::WakeLockServicePtr wake_lock_1;
+  mojom::WakeLockServicePtr wake_lock_2;
+  mojom::WakeLockServicePtr wake_lock_3;
+  wake_lock_->AddClient(mojo::MakeRequest(&wake_lock_1));
+  wake_lock_->AddClient(mojo::MakeRequest(&wake_lock_2));
+  wake_lock_->AddClient(mojo::MakeRequest(&wake_lock_3));
+
+  EXPECT_FALSE(HasWakeLock());
+
+  wake_lock_1->RequestWakeLock();
+  wake_lock_2->RequestWakeLock();
+  wake_lock_3->RequestWakeLock();
+  EXPECT_TRUE(HasWakeLock());
+
+  wake_lock_1->CancelWakeLock();
+  wake_lock_2->CancelWakeLock();
+  EXPECT_TRUE(HasWakeLock());
+
+  wake_lock_3->CancelWakeLock();
+  EXPECT_FALSE(HasWakeLock());
+}
+
+// WakeLockService should update the wake lock status correctly when
+// connection error happens.
+TEST_F(WakeLockServiceImplTest, OnWakeLockConnectionError) {
+  EXPECT_FALSE(HasWakeLock());
+
+  mojom::WakeLockServicePtr wake_lock_1;
+  mojom::WakeLockServicePtr wake_lock_2;
+  mojom::WakeLockServicePtr wake_lock_3;
+  wake_lock_->AddClient(mojo::MakeRequest(&wake_lock_1));
+  wake_lock_->AddClient(mojo::MakeRequest(&wake_lock_2));
+  wake_lock_->AddClient(mojo::MakeRequest(&wake_lock_3));
+
+  EXPECT_FALSE(HasWakeLock());
+
+  wake_lock_1->RequestWakeLock();
+  wake_lock_2->RequestWakeLock();
+  wake_lock_3->RequestWakeLock();
+  EXPECT_TRUE(HasWakeLock());
+
+  wake_lock_1.reset();
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(HasWakeLock());
+
+  wake_lock_2.reset();
+  wake_lock_3.reset();
+  base::RunLoop().RunUntilIdle();
+  EXPECT_FALSE(HasWakeLock());
+}
+
+// Test mixed operations.
+TEST_F(WakeLockServiceImplTest, MixedTest) {
+  EXPECT_FALSE(HasWakeLock());
+
+  mojom::WakeLockServicePtr wake_lock_1;
+  mojom::WakeLockServicePtr wake_lock_2;
+  mojom::WakeLockServicePtr wake_lock_3;
+  wake_lock_->AddClient(mojo::MakeRequest(&wake_lock_1));
+  wake_lock_->AddClient(mojo::MakeRequest(&wake_lock_2));
+  wake_lock_->AddClient(mojo::MakeRequest(&wake_lock_3));
+
+  EXPECT_FALSE(HasWakeLock());
+
+  // Execute a series of calls that should result in |wake_lock_1| and
+  // |wake_lock_3| having outstanding wake lock requests.
+  wake_lock_1->RequestWakeLock();
+  wake_lock_1->CancelWakeLock();
+  wake_lock_2->RequestWakeLock();
+  wake_lock_1->RequestWakeLock();
+  wake_lock_1->RequestWakeLock();
+  wake_lock_3->CancelWakeLock();
+  wake_lock_3->CancelWakeLock();
+  wake_lock_2->CancelWakeLock();
+  wake_lock_3->RequestWakeLock();
+  wake_lock_2.reset();
+  EXPECT_TRUE(HasWakeLock());
+
+  wake_lock_1.reset();
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(HasWakeLock());
+
+  wake_lock_3->CancelWakeLock();
+  EXPECT_FALSE(HasWakeLock());
+}
+
+}  // namespace
+
+}  // namespace device