Tests for WaitUntilObserver and focus/openining windows.

Source/modules/serviceworkers/WaitUntilObserver.cpp

 // 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 "config.h"
 #include "modules/serviceworkers/WaitUntilObserver.h"
 
 #include "bindings/core/v8/ScriptFunction.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
 #include "modules/serviceworkers/ServiceWorkerGlobalScope.h"
+#include "platform/LayoutTestSupport.h"
 #include "platform/NotImplemented.h"
 #include "public/platform/WebServiceWorkerEventResult.h"
 #include "wtf/Assertions.h"
 #include "wtf/RefCounted.h"
 #include "wtf/RefPtr.h"
 #include <v8.h>
 
 namespace blink {
 
+namespace {
+
+// Timeout before a service worker that was given window interaction
+// permission loses them. The unit is seconds.
+const unsigned kWindowInteractionTimeout = 10;
+const unsigned kWindowInteractionTimeoutForTest = 1;
+
+unsigned windowInteractionTimeout()
+{
+    return LayoutTestSupport::isRunningLayoutTest()
+        ? kWindowInteractionTimeoutForTest : kWindowInteractionTimeout;
+}
+
+} // anonymous namespace
+
 class WaitUntilObserver::ThenFunction final : public ScriptFunction {
 public:
     enum ResolveType {
         Fulfilled,
         Rejected,
     };
 
     static v8::Handle<v8::Function> createFunction(ScriptState* scriptState, WaitUntilObserver* observer, ResolveType type)
     {
         ThenFunction* self = new ThenFunction(scriptState, observer, type);
@@ skipping 29 matching lines @@
     ResolveType m_resolveType;
 };
 
 WaitUntilObserver* WaitUntilObserver::create(ExecutionContext* context, EventType type, int eventID)
 {
     return new WaitUntilObserver(context, type, eventID);
 }
 
 void WaitUntilObserver::willDispatchEvent()
 {
+    // When handling a notificationclick event, we want to allow one window to
+    // be focused or opened. These calls are allowed between the call to
+    // willDispatchEvent() and the last call to decrementPendingActivity(). If
+    // waitUntil() isn't called, that means between willDispatchEvent() and
+    // didDispatchEvent().
+    if (m_type == NotificationClick)
+        executionContext()->allowWindowInteraction();
+
     incrementPendingActivity();
 }
 
 void WaitUntilObserver::didDispatchEvent(bool errorOccurred)
 {
     if (errorOccurred)
         m_hasError = true;
     decrementPendingActivity();
     m_eventDispatched = true;
 }
 
 void WaitUntilObserver::waitUntil(ScriptState* scriptState, const ScriptValue& value, ExceptionState& exceptionState)
 {
     if (m_eventDispatched) {
         exceptionState.throwDOMException(InvalidStateError, "The event handler is already finished.");
         return;
     }
 
     if (!executionContext())
         return;
 
     // When handling a notificationclick event, we want to allow one window to
-    // be focused or opened. Regardless of whether such action happened,
-    // |consumeWindowInteraction| will be called when all the pending activities
-    // will be resolved or after a
-    if (m_type == NotificationClick) {
-        executionContext()->allowWindowInteraction();
-        m_consumeWindowInteractionTimer.startOneShot(ServiceWorkerGlobalScope::kWindowInteractionTimeout, FROM_HERE);
-    }
+    // be focused or opened. See comments in ::willDispatchEvent(). When
+    // waitUntil() is being used, opening or closing a window must happen in a
+    // timeframe specified by windowInteractionTimeout(), otherwise the calls
+    // will fail.
+    if (m_type == NotificationClick)
+        m_consumeWindowInteractionTimer.startOneShot(windowInteractionTimeout(), FROM_HERE);
 
     incrementPendingActivity();
     ScriptPromise::cast(scriptState, value).then(
         ThenFunction::createFunction(scriptState, this, ThenFunction::Fulfilled),
         ThenFunction::createFunction(scriptState, this, ThenFunction::Rejected));
 }
 
 WaitUntilObserver::WaitUntilObserver(ExecutionContext* context, EventType type, int eventID)
     : ContextLifecycleObserver(context)
     , m_type(type)
@@ skipping 51 matching lines @@
         return;
     executionContext()->consumeWindowInteraction();
 }
 
 DEFINE_TRACE(WaitUntilObserver)
 {
     ContextLifecycleObserver::trace(visitor);
 }
 
 } // namespace blink