[Playground] Onion Soup: moving ScreenWakeLock to Blink modules/

third_party/WebKit/Source/modules/wake_lock/ScreenWakeLockTest.cpp

 // Copyright 2015 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 "modules/wake_lock/ScreenWakeLock.h"
 
+#include "base/run_loop.h"
 #include "core/dom/DOMImplementation.h"
 #include "core/dom/Document.h"
 #include "core/dom/DocumentInit.h"
-#include "core/frame/LocalDOMWindow.h"
-#include "platform/heap/Handle.h"
+#include "mojo/public/cpp/bindings/interface_request.h"
+#include "mojo/public/cpp/bindings/strong_binding.h"
 #include "platform/testing/URLTestHelpers.h"
 #include "public/platform/Platform.h"
+#include "public/platform/ServiceRegistry.h"
 #include "public/platform/WebPageVisibilityState.h"
 #include "public/platform/WebURLLoaderMockFactory.h"
-#include "public/platform/modules/wake_lock/WebWakeLockClient.h"
 #include "public/web/WebCache.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "web/WebLocalFrameImpl.h"
 #include "web/tests/FrameTestHelpers.h"
 
 namespace {
 
 using blink::ScreenWakeLock;
-using blink::WebWakeLockClient;
+using blink::mojom::WakeLockService;
+using blink::mojom::WakeLockServiceRequest;
 
-class TestWebWakeLockClient: public WebWakeLockClient {
+// This class allows connecting service requests to a MockWakeLockService.
+class MockServiceRegistry : public blink::ServiceRegistry {
 public:
-    TestWebWakeLockClient(): m_keepScreenAwake(false) { }
+    MockServiceRegistry() : m_wakeLockStatus(false) {}
+    ~MockServiceRegistry() = default;
 
-    void requestKeepScreenAwake(bool keepScreenAwake) override
-    {
-        m_keepScreenAwake = keepScreenAwake;
-    }
+    void connectToRemoteService(const char* name, mojo::ScopedMessagePipeHandle) override;
 
-    bool keepScreenAwake() const { return m_keepScreenAwake; }
+    bool wakeLockStatus() const { return m_wakeLockStatus; }
+    void setWakeLockStatus(bool status) { m_wakeLockStatus = status; }
 
 private:
-    bool m_keepScreenAwake;
+    bool m_wakeLockStatus;
 };
 
-class TestWebFrameClient: public blink::FrameTestHelpers::TestWebFrameClient {
+// This class is a mock WakeLockService to intercept calls to the mojo methods.
+class MockWakeLockService : public WakeLockService {
 public:
-    WebWakeLockClient* wakeLockClient() override
+    static void Create(MockServiceRegistry* registry, WakeLockServiceRequest request)
     {
-        return &m_testWebWakeLockClient;
+        // See comment below in |m_binding_| for why this doesn't leak.
+        new MockWakeLockService(registry, std::move(request));
     }
-
-    const TestWebWakeLockClient& testWebWakeLockClient() const
-    {
-        return m_testWebWakeLockClient;
-    }
+    ~MockWakeLockService() = default;
 
 private:
-    TestWebWakeLockClient m_testWebWakeLockClient;
+    MockWakeLockService(MockServiceRegistry* registry, WakeLockServiceRequest request)
+        : m_binding(this, std::move(request))
+        , m_registry(registry) {}
+
+    // mojom::WakeLockService
+    void RequestWakeLock() override { m_registry->setWakeLockStatus(true); }
+    void CancelWakeLock() override { m_registry->setWakeLockStatus(false); }
+
+    // A StrongBinding is just like a Binding, except that it takes ownership of
+    // its bound implementation and deletes itself (and the impl) if and when the
+    // bound pipe encounters an error or is closed on the other end.
+    mojo::StrongBinding<WakeLockService> m_binding;
+    MockServiceRegistry* const m_registry;
+};
+
+// This implementation goes here for MockWakeLockService to be defined.
+void MockServiceRegistry::connectToRemoteService(const char* name, mojo::ScopedMessagePipeHandle handle)
+{
+    MockWakeLockService::Create(this, mojo::MakeRequest<WakeLockService>(std::move(handle)));
+}
+
+// A TestWebFrameClient to allow overriding the serviceRegistry() with a mock.
+class TestWebFrameClient : public blink::FrameTestHelpers::TestWebFrameClient {
+public:
+    ~TestWebFrameClient() override = default;
+    blink::ServiceRegistry* serviceRegistry() override { return &m_serviceRegistry; }
+
+private:
+    MockServiceRegistry m_serviceRegistry;
 };
 
 class ScreenWakeLockTest: public testing::Test {
 protected:
     void SetUp() override
     {
         m_webViewHelper.initialize(true, &m_testWebFrameClient);
         blink::URLTestHelpers::registerMockedURLFromBaseURL(
             blink::WebString::fromUTF8("http://example.com/"),
             blink::WebString::fromUTF8("foo.html"));
@@ skipping 29 matching lines @@
     }
 
     bool screenKeepAwake()
     {
         DCHECK(screen());
         return ScreenWakeLock::keepAwake(*screen());
     }
 
     bool clientKeepScreenAwake()
     {
-        return m_testWebFrameClient.testWebWakeLockClient().keepScreenAwake();
+        return static_cast<MockServiceRegistry*>(m_testWebFrameClient.serviceRegistry())->wakeLockStatus();
     }
 
     void setKeepAwake(bool keepAwake)
     {
         DCHECK(screen());
         ScreenWakeLock::setKeepAwake(*screen(), keepAwake);
+        // Let the notification sink through the mojo pipes.
+        base::RunLoop().RunUntilIdle();
     }
 
     void show()
     {
         DCHECK(m_webViewHelper.webView());
         m_webViewHelper.webView()->setVisibilityState(
             blink::WebPageVisibilityStateVisible, false);
+        // Let the notification sink through the mojo pipes.
+        base::RunLoop().RunUntilIdle();
     }
 
     void hide()
     {
         DCHECK(m_webViewHelper.webView());
         m_webViewHelper.webView()->setVisibilityState(
             blink::WebPageVisibilityStateHidden, false);
+        // Let the notification sink through the mojo pipes.
+        base::RunLoop().RunUntilIdle();
     }
 
     // Order of these members is important as we need to make sure that
     // m_testWebFrameClient outlives m_webViewHelper (destruction order)
     TestWebFrameClient m_testWebFrameClient;
     blink::FrameTestHelpers::WebViewHelper m_webViewHelper;
 };
 
 TEST_F(ScreenWakeLockTest, setAndReset)
 {
@@ skipping 52 matching lines @@
     ASSERT_FALSE(clientKeepScreenAwake());
 
     setKeepAwake(true);
     loadFrame();
 
     EXPECT_FALSE(screenKeepAwake());
     EXPECT_FALSE(clientKeepScreenAwake());
 }
 
 } // namespace