OLD | NEW |
(Empty) | |
| 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "config.h" |
| 6 |
| 7 #include "modules/wake_lock/WakeLock.h" |
| 8 |
| 9 #include "bindings/core/v8/ScriptState.h" |
| 10 #include "bindings/core/v8/V8Binding.h" |
| 11 #include "core/dom/Document.h" |
| 12 #include "core/html/HTMLElement.h" |
| 13 #include "core/page/Page.h" |
| 14 #include "modules/wake_lock/WakeLockController.h" |
| 15 #include "public/platform/Platform.h" |
| 16 #include "public/platform/WebUnitTestSupport.h" |
| 17 #include "public/platform/WebWakeLockClient.h" |
| 18 #include "public/platform/WebWakeLockRequestCallback.h" |
| 19 #include "public/web/WebDocument.h" |
| 20 #include "public/web/WebView.h" |
| 21 #include "web/WebLocalFrameImpl.h" |
| 22 #include "web/WebViewImpl.h" |
| 23 #include "web/tests/FrameTestHelpers.h" |
| 24 #include "web/tests/URLTestHelpers.h" |
| 25 #include "wtf/Vector.h" |
| 26 |
| 27 #include <gtest/gtest.h> |
| 28 |
| 29 namespace { |
| 30 struct WakeLockRequestInfo { |
| 31 blink::WebWakeLockType m_type; |
| 32 int m_requestId; |
| 33 WakeLockRequestInfo(blink::WebWakeLockType type, int id) |
| 34 : m_type(type) |
| 35 , m_requestId(id) |
| 36 { |
| 37 } |
| 38 }; |
| 39 typedef Vector<WakeLockRequestInfo> Requests; |
| 40 |
| 41 class MockWebWakeLockClient : public blink::WebWakeLockClient { |
| 42 public: |
| 43 MockWebWakeLockClient() |
| 44 : m_callback(0) |
| 45 { |
| 46 } |
| 47 |
| 48 virtual ~MockWebWakeLockClient() { }; |
| 49 |
| 50 virtual void requestWakeLock(blink::WebWakeLockType type, int requestId, bli
nk::WebSecurityOrigin) |
| 51 { |
| 52 m_lockRequests.append(WakeLockRequestInfo(type, requestId)); |
| 53 }; |
| 54 |
| 55 virtual void requestWakeUnlock(blink::WebWakeLockType type, int requestId) |
| 56 { |
| 57 m_unlockRequests.append(WakeLockRequestInfo(type, requestId)); |
| 58 }; |
| 59 |
| 60 virtual void wakeLockDestroyed() { m_callback = 0; }; |
| 61 virtual void setRequestCallback(blink::WebWakeLockRequestCallback* callback) |
| 62 { |
| 63 m_callback = callback; |
| 64 }; |
| 65 |
| 66 void resolveLockRequest(blink::WebWakeLockType type, bool success) |
| 67 { |
| 68 for (size_t pos = 0; pos < m_lockRequests.size();) { |
| 69 blink::WebWakeLockType requestType = m_lockRequests.at(pos).m_type; |
| 70 int resolverId = m_lockRequests.at(pos).m_requestId; |
| 71 if (m_callback && (requestType == type)) { |
| 72 if (success) |
| 73 m_callback->onCreatedWakeLockSuccessful(resolverId); |
| 74 else |
| 75 m_callback->onCreatedWakeLockFailed(resolverId); |
| 76 m_lockRequests.remove(pos); |
| 77 } else { |
| 78 ++pos; |
| 79 } |
| 80 } |
| 81 } |
| 82 |
| 83 void resolveUnlockRequest(blink::WebWakeLockType type, bool success) |
| 84 { |
| 85 for (size_t pos = 0; pos < m_unlockRequests.size();) { |
| 86 blink::WebWakeLockType requestType = m_unlockRequests.at(pos).m_type
; |
| 87 int resolverId = m_unlockRequests.at(pos).m_requestId; |
| 88 if (m_callback && (requestType == type)) { |
| 89 if (success) |
| 90 m_callback->onUnlockedWakeLockSuccessful(resolverId); |
| 91 else |
| 92 m_callback->onUnlockedWakeLockFailed(resolverId); |
| 93 m_unlockRequests.remove(pos); |
| 94 } else { |
| 95 ++pos; |
| 96 } |
| 97 } |
| 98 } |
| 99 |
| 100 private: |
| 101 blink::WebWakeLockRequestCallback *m_callback; |
| 102 |
| 103 Requests m_lockRequests; |
| 104 Requests m_unlockRequests; |
| 105 }; |
| 106 |
| 107 class WakeLockTest : public testing::Test { |
| 108 public: |
| 109 WakeLockTest() |
| 110 : m_baseURL("http://www.test.com/") |
| 111 { |
| 112 } |
| 113 |
| 114 protected: |
| 115 virtual void SetUp() OVERRIDE |
| 116 { |
| 117 m_webViewHelper.initialize(true, 0, &m_mockWebViewClient, 0); |
| 118 webViewImpl()->resize(blink::WebSize(320, 240)); |
| 119 } |
| 120 |
| 121 virtual void TearDown() OVERRIDE |
| 122 { |
| 123 blink::Platform::current()->unitTestSupport()->unregisterAllMockedURLs()
; |
| 124 } |
| 125 |
| 126 void registerMockedHttpURLLoad(const std::string& fileName) |
| 127 { |
| 128 blink::URLTestHelpers::registerMockedURLFromBaseURL(blink::WebString::fr
omUTF8(m_baseURL.c_str()), blink::WebString::fromUTF8(fileName.c_str())); |
| 129 } |
| 130 |
| 131 blink::Document* document() const { return frame()->document(); } |
| 132 blink::Page* page() const { return frame()->page(); } |
| 133 |
| 134 blink::WebViewImpl* webViewImpl() const { return m_webViewHelper.webViewImpl
(); } |
| 135 blink::LocalFrame* frame() const { return m_webViewHelper.webViewImpl()->mai
nFrameImpl()->frame(); } |
| 136 |
| 137 void navigateTo(const std::string& url) |
| 138 { |
| 139 blink::FrameTestHelpers::loadFrame(webViewImpl()->mainFrame(), url); |
| 140 } |
| 141 |
| 142 void forceFullCompositingUpdate() { webViewImpl()->layout(); } |
| 143 |
| 144 std::string m_baseURL; |
| 145 |
| 146 private: |
| 147 blink::FrameTestHelpers::TestWebViewClient m_mockWebViewClient; |
| 148 blink::FrameTestHelpers::WebViewHelper m_webViewHelper; |
| 149 }; |
| 150 |
| 151 TEST_F(WakeLockTest, requestReleasePromise) |
| 152 { |
| 153 registerMockedHttpURLLoad("foo.html"); |
| 154 navigateTo(m_baseURL + "foo.html"); |
| 155 forceFullCompositingUpdate(); |
| 156 |
| 157 ASSERT_TRUE(document()); |
| 158 ASSERT_TRUE(page()); |
| 159 |
| 160 MockWebWakeLockClient wakeLockClient; |
| 161 blink::WakeLockController::provideWakeLockTo(*page(), &wakeLockClient); |
| 162 blink::WakeLockController* wakeLockController = blink::WakeLockController::f
rom(page()); |
| 163 ASSERT_TRUE(wakeLockController); |
| 164 |
| 165 wakeLockClient.setRequestCallback(blink::WakeLockController::from(page())); |
| 166 |
| 167 blink::ScriptState* scriptState = blink::ScriptState::forMainWorld(frame()); |
| 168 blink::ScriptState::Scope scriptScope(scriptState); |
| 169 RefPtr<blink::WakeLock> wakeLock = blink::WakeLock::create(document()->domWi
ndow()->executionContext()); |
| 170 |
| 171 { |
| 172 blink::ScriptPromise promise = wakeLock->request(scriptState, "screen"); |
| 173 wakeLockClient.resolveLockRequest(blink::WebWakeLockScreen, true); |
| 174 |
| 175 ASSERT_FALSE(promise.isEmpty()); |
| 176 ASSERT_TRUE(promise.v8Value()->IsPromise()); |
| 177 |
| 178 ASSERT_TRUE(wakeLockController->isHeld(blink::WebWakeLockScreen)); |
| 179 |
| 180 promise = wakeLock->release(scriptState, "screen"); |
| 181 wakeLockClient.resolveUnlockRequest(blink::WebWakeLockScreen, true); |
| 182 ASSERT_FALSE(promise.isEmpty()); |
| 183 ASSERT_TRUE(promise.v8Value()->IsPromise()); |
| 184 |
| 185 ASSERT_FALSE(wakeLockController->isHeld(blink::WebWakeLockScreen)); |
| 186 } |
| 187 |
| 188 { |
| 189 blink::ScriptPromise promise = wakeLock->release(scriptState, "screen"); |
| 190 ASSERT_FALSE(promise.isEmpty()); |
| 191 ASSERT_TRUE(promise.v8Value()->IsPromise()); |
| 192 |
| 193 wakeLockClient.resolveUnlockRequest(blink::WebWakeLockScreen, true); |
| 194 |
| 195 ASSERT_FALSE(wakeLockController->isHeld(blink::WebWakeLockScreen)); |
| 196 } |
| 197 |
| 198 { |
| 199 blink::ScriptPromise promise = wakeLock->request(scriptState, "screen"); |
| 200 ASSERT_FALSE(promise.isEmpty()); |
| 201 ASSERT_TRUE(promise.v8Value()->IsPromise()); |
| 202 |
| 203 wakeLockClient.resolveLockRequest(blink::WebWakeLockScreen, false); |
| 204 |
| 205 ASSERT_FALSE(wakeLockController->isHeld(blink::WebWakeLockScreen)); |
| 206 } |
| 207 |
| 208 { |
| 209 blink::ScriptPromise promise1 = wakeLock->request(scriptState, "screen")
; |
| 210 blink::ScriptPromise promise2 = wakeLock->request(scriptState, "screen")
; |
| 211 wakeLockClient.resolveLockRequest(blink::WebWakeLockScreen, true); |
| 212 ASSERT_FALSE(promise1.isEmpty()); |
| 213 ASSERT_FALSE(promise2.isEmpty()); |
| 214 ASSERT_TRUE(promise1.v8Value()->IsPromise()); |
| 215 ASSERT_TRUE(promise2.v8Value()->IsPromise()); |
| 216 |
| 217 ASSERT_TRUE(wakeLockController->isHeld(blink::WebWakeLockScreen)); |
| 218 |
| 219 promise1 = wakeLock->release(scriptState, "screen"); |
| 220 promise2 = wakeLock->release(scriptState, "screen"); |
| 221 wakeLockClient.resolveUnlockRequest(blink::WebWakeLockScreen, true); |
| 222 ASSERT_FALSE(promise1.isEmpty()); |
| 223 ASSERT_FALSE(promise2.isEmpty()); |
| 224 ASSERT_TRUE(promise1.v8Value()->IsPromise()); |
| 225 ASSERT_TRUE(promise2.v8Value()->IsPromise()); |
| 226 |
| 227 ASSERT_FALSE(wakeLockController->isHeld(blink::WebWakeLockScreen)); |
| 228 } |
| 229 |
| 230 { |
| 231 blink::ScriptPromise promise1 = wakeLock->request(scriptState, "screen")
; |
| 232 blink::ScriptPromise promise2 = wakeLock->request(scriptState, "screen")
; |
| 233 wakeLockClient.resolveLockRequest(blink::WebWakeLockScreen, true); |
| 234 ASSERT_FALSE(promise1.isEmpty()); |
| 235 ASSERT_FALSE(promise2.isEmpty()); |
| 236 ASSERT_TRUE(promise1.v8Value()->IsPromise()); |
| 237 ASSERT_TRUE(promise2.v8Value()->IsPromise()); |
| 238 |
| 239 ASSERT_TRUE(wakeLockController->isHeld(blink::WebWakeLockScreen)); |
| 240 |
| 241 promise1 = wakeLock->release(scriptState, "screen"); |
| 242 ASSERT_FALSE(promise1.isEmpty()); |
| 243 ASSERT_TRUE(promise1.v8Value()->IsPromise()); |
| 244 |
| 245 wakeLockClient.resolveUnlockRequest(blink::WebWakeLockScreen, true); |
| 246 ASSERT_TRUE(wakeLockController->isHeld(blink::WebWakeLockScreen)); |
| 247 |
| 248 promise2 = wakeLock->release(scriptState, "screen"); |
| 249 ASSERT_FALSE(promise2.isEmpty()); |
| 250 ASSERT_TRUE(promise2.v8Value()->IsPromise()); |
| 251 |
| 252 wakeLockClient.resolveUnlockRequest(blink::WebWakeLockScreen, false); |
| 253 ASSERT_TRUE(wakeLockController->isHeld(blink::WebWakeLockScreen)); |
| 254 |
| 255 promise2 = wakeLock->release(scriptState, "screen"); |
| 256 ASSERT_FALSE(promise2.isEmpty()); |
| 257 ASSERT_TRUE(promise2.v8Value()->IsPromise()); |
| 258 |
| 259 wakeLockClient.resolveUnlockRequest(blink::WebWakeLockScreen, true); |
| 260 ASSERT_FALSE(wakeLockController->isHeld(blink::WebWakeLockScreen)); |
| 261 } |
| 262 |
| 263 wakeLockController->resetClient(); |
| 264 } |
| 265 |
| 266 } // namespace |
OLD | NEW |