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/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 {
+
+unsigned& windowInteractionTimeout()
+{
+    DEFINE_STATIC_LOCAL(unsigned, windowInteractionTimeout, (ServiceWorkerGlobalScope::kWindowInteractionTimeout));
+    return windowInteractionTimeout;
+}
+
+} // 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();

[dominicc (has gone to gerrit), 2015/02/05 18:58:13]

Does it make sense to assert that this has been reset by the time the object is
destructed (or at some other/more points?)

[mlamouri (slow - plz ping), 2015/02/05 20:23:12]

Not really. The callers are not aware of the number of tokens the
ExecutionContext currently have. There might be multiple WaitUntilObserver
running at the same time in which case after one dies, it will still be allowed
to open/focus a window. Because of that, there isn't much sanity check we can
do.

+
     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 45 matching lines @@
     observeContext(0);
 }
 
 void WaitUntilObserver::consumeWindowInteraction(Timer<WaitUntilObserver>*)
 {
     if (!executionContext())
         return;
     executionContext()->consumeWindowInteraction();
 }
 
+// static
+void WaitUntilObserver::overrideWindowInteractionTimeoutForTest(unsigned timeout)
+{
+    windowInteractionTimeout() = timeout;
+}
+
 void WaitUntilObserver::trace(Visitor* visitor)
 {
     ContextLifecycleObserver::trace(visitor);
 }
 
 } // namespace blink