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));
+    fprintf(stderr, "%s%d\n", "windowInteractionTimeout = ", windowInteractionTimeout);

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

Hmm, what happens if unit tests run in parallel?

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

Yeah... So I moved to another model. There is now another
kWindowInteractionTimeout (ForTest) in SWGlobalScope and WaitUntilObserver is
using it when running in LayoutTests.

+    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 56 matching lines @@
 
     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);
+        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)
@@ skipping 41 matching lines @@
         break;
     case Push:
         client->didHandlePushEvent(m_eventID, result);
         break;
     }
     observeContext(0);
 }
 
 void WaitUntilObserver::consumeWindowInteraction(Timer<WaitUntilObserver>*)
 {
+    fprintf(stderr, "%s\n", "consumeWindowInteraction");

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

Remove the logging.

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

Removed in patch #2.

     if (!executionContext())
         return;
     executionContext()->consumeWindowInteraction();
 }
 
+// static
+void WaitUntilObserver::overrideWindowInteractionTimeoutForTest(unsigned timeout)
+{
+    windowInteractionTimeout() = timeout;
+}
+
 void WaitUntilObserver::trace(Visitor* visitor)
 {
     ContextLifecycleObserver::trace(visitor);
 }
 
 } // namespace blink