Implement the unprefixed the Fullscreen API

Source/core/dom/FullscreenElementStack.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
@@ skipping 55 matching lines @@
 
 static bool fullscreenIsSupported(const Document& document, const Element& element)
 {
     if (!document.settings() || (document.settings()->disallowFullscreenForNonMediaElements() && !isHTMLMediaElement(element)))
         return false;
     return fullscreenIsSupported(document);
 }
 
 static PassRefPtrWillBeRawPtr<Event> createEvent(const AtomicString& type, EventTarget& target)
 {
-    RefPtrWillBeRawPtr<Event> event = Event::createBubble(type);
+    EventInit initializer;
+    // The prefixed events bubble, the unprefixed ones do not.
+    initializer.bubbles = type == EventTypeNames::webkitfullscreenchange || type == EventTypeNames::webkitfullscreenerror;

[falken, 2014/08/12 03:26:08]

This boolean expression appears again later. wdyt of making a function like
isPrefixedEvent()? Then the comment can also be removed as it's
self-explanatory.

[philipj_slow, 2014/08/12 08:09:53]

Good idea, done!

+    RefPtrWillBeRawPtr<Event> event = Event::create(type, initializer);
     event->setTarget(&target);
     return event;
 }
 
 const char* FullscreenElementStack::supplementName()
 {
     return "FullscreenElementStack";
 }
 
 FullscreenElementStack& FullscreenElementStack::from(Document& document)
@@ skipping 163 matching lines @@
 
             // 1. Let following document be the document after document in docs, or null if there is no
             // such document.
             Document* currentDoc = *current;
             Document* followingDoc = following != docs.end() ? *following : 0;
 
             // 2. If following document is null, push context object on document's fullscreen element
             // stack, and queue a task to fire an event named fullscreenchange with its bubbles attribute
             // set to true on the document.
             if (!followingDoc) {
-                from(*currentDoc).pushFullscreenElementStack(element);
-                enqueueChangeEvent(*currentDoc);
+                from(*currentDoc).pushFullscreenElementStack(element, requestType);
+                enqueueChangeEvent(*currentDoc, requestType);
                 continue;
             }
 
             // 3. Otherwise, if document's fullscreen element stack is either empty or its top element
             // is not following document's browsing context container,
             Element* topElement = fullscreenElementFrom(*currentDoc);
             if (!topElement || topElement != followingDoc->ownerElement()) {
                 // ...push following document's browsing context container on document's fullscreen element
                 // stack, and queue a task to fire an event named fullscreenchange with its bubbles attribute
                 // set to true on document.
-                from(*currentDoc).pushFullscreenElementStack(*followingDoc->ownerElement());
-                enqueueChangeEvent(*currentDoc);
+                from(*currentDoc).pushFullscreenElementStack(*followingDoc->ownerElement(), requestType);
+                enqueueChangeEvent(*currentDoc, requestType);
                 continue;
             }
 
             // 4. Otherwise, do nothing for this document. It stays the same.
         } while (++current != docs.end());
 
         // 5. Return, and run the remaining steps asynchronously.
         // 6. Optionally, perform some animation.
         m_areKeysEnabledInFullScreen = requestType != PrefixedMozillaRequest && requestType != PrefixedVideoRequest;
         document()->frameHost()->chrome().client().enterFullScreenForElement(&element);
 
         // 7. Optionally, display a message indicating how the user can exit displaying the context object fullscreen.
         return;
     } while (0);
 
-    enqueueErrorEvent(element);
+    enqueueErrorEvent(element, requestType);
 }
 
 void FullscreenElementStack::fullyExitFullscreen()
 {
     // "To fully exit fullscreen act as if the exitFullscreen() method was invoked on the top-level browsing
     // context's document and subsequently empty that document's fullscreen element stack."
     if (!fullscreenElementFrom(document()->topDocument()))
         return;
 
     // To achieve that aim, remove all the elements from the top document's stack except for the first before
     // calling exitFullscreen():
-    WillBeHeapVector<RefPtrWillBeMember<Element> > replacementFullscreenElementStack;
-    replacementFullscreenElementStack.append(fullscreenElementFrom(document()->topDocument()));
+    WillBeHeapVector<std::pair<RefPtrWillBeMember<Element>, RequestType> > replacementFullscreenElementStack;
     FullscreenElementStack& topFullscreenElementStack = from(document()->topDocument());
+    replacementFullscreenElementStack.append(topFullscreenElementStack.m_fullScreenElementStack.last());
     topFullscreenElementStack.m_fullScreenElementStack.swap(replacementFullscreenElementStack);
     topFullscreenElementStack.exitFullscreen();
 }
 
 void FullscreenElementStack::exitFullscreen()
 {
     // The exitFullscreen() method must run these steps:
 
     // 1. Let doc be the context object. (i.e. "this")
     Document* currentDoc = document();
@@ skipping 13 matching lines @@
             continue;
         ASSERT(toLocalFrame(descendant)->document());
         if (fullscreenElementFrom(*toLocalFrame(descendant)->document()))
             descendants.prepend(toLocalFrame(descendant)->document());
     }
 
     // 4. For each descendant in descendants, empty descendant's fullscreen element stack, and queue a
     // task to fire an event named fullscreenchange with its bubbles attribute set to true on descendant.
     for (WillBeHeapDeque<RefPtrWillBeMember<Document> >::iterator i = descendants.begin(); i != descendants.end(); ++i) {
         ASSERT(*i);
+        RequestType requestType = from(**i).m_fullScreenElementStack.last().second;
         from(**i).clearFullscreenElementStack();
-        enqueueChangeEvent(**i);
+        enqueueChangeEvent(**i, requestType);
     }
 
     // 5. While doc is not null, run these substeps:
     Element* newTop = 0;
     while (currentDoc) {
+        RequestType requestType = from(*currentDoc).m_fullScreenElementStack.last().second;
+
         // 1. Pop the top element of doc's fullscreen element stack.
         from(*currentDoc).popFullscreenElementStack();
 
         //    If doc's fullscreen element stack is non-empty and the element now at the top is either
         //    not in a document or its node document is not doc, repeat this substep.
         newTop = fullscreenElementFrom(*currentDoc);
         if (newTop && (!newTop->inDocument() || newTop->document() != currentDoc))
             continue;
 
         // 2. Queue a task to fire an event named fullscreenchange with its bubbles attribute set to true
         // on doc.
-        enqueueChangeEvent(*currentDoc);
+        enqueueChangeEvent(*currentDoc, requestType);
 
         // 3. If doc's fullscreen element stack is empty and doc's browsing context has a browsing context
         // container, set doc to that browsing context container's node document.
         if (!newTop && currentDoc->ownerElement()) {
             currentDoc = &currentDoc->ownerElement()->document();
             continue;
         }
 
         // 4. Otherwise, set doc to null.
         currentDoc = 0;
@@ skipping 131 matching lines @@
     ASSERT(!m_fullScreenRenderer);
 
     m_fullScreenRenderer = renderer;
 }
 
 void FullscreenElementStack::fullScreenRendererDestroyed()
 {
     m_fullScreenRenderer = nullptr;
 }
 
-void FullscreenElementStack::enqueueChangeEvent(Document& document)
+void FullscreenElementStack::enqueueChangeEvent(Document& document, RequestType requestType)
 {
-    ASSERT(document.hasFullscreenElementStack());
-    FullscreenElementStack& fullscreen = from(document);
-
-    EventTarget* target = fullscreen.fullscreenElement();
-    if (!target)
-        target = fullscreen.webkitCurrentFullScreenElement();
-    if (!target)
-        target = &document;
-    m_eventQueue.append(createEvent(EventTypeNames::webkitfullscreenchange, *target));
+    RefPtrWillBeRawPtr<Event> event;
+    if (requestType == UnprefixedRequest) {
+        event = createEvent(EventTypeNames::fullscreenchange, document);
+    } else {
+        ASSERT(document.hasFullscreenElementStack());
+        FullscreenElementStack& fullscreen = from(document);
+        EventTarget* target = fullscreen.fullscreenElement();
+        if (!target)
+            target = fullscreen.webkitCurrentFullScreenElement();
+        if (!target)
+            target = &document;
+        event = createEvent(EventTypeNames::webkitfullscreenchange, *target);
+    }
+    m_eventQueue.append(event);
     // NOTE: The timer is started in didEnterFullScreenForElement/didExitFullScreenForElement.
 }
 
-void FullscreenElementStack::enqueueErrorEvent(Element& element)
+void FullscreenElementStack::enqueueErrorEvent(Element& element, RequestType requestType)
 {
-    m_eventQueue.append(createEvent(EventTypeNames::webkitfullscreenerror, element));
+    RefPtrWillBeRawPtr<Event> event;
+    if (requestType == UnprefixedRequest)
+        event = createEvent(EventTypeNames::fullscreenerror, element.document());
+    else
+        event = createEvent(EventTypeNames::webkitfullscreenerror, element);
+    m_eventQueue.append(event);
     m_eventQueueTimer.startOneShot(0, FROM_HERE);
 }
 
 void FullscreenElementStack::eventQueueTimerFired(Timer<FullscreenElementStack>*)
 {
     // Since we dispatch events in this function, it's possible that the
     // document will be detached and GC'd. We protect it here to make sure we
     // can finish the function successfully.
     RefPtrWillBeRawPtr<Document> protectDocument(document());
     WillBeHeapDeque<RefPtrWillBeMember<Event> > eventQueue;
     m_eventQueue.swap(eventQueue);
 
     while (!eventQueue.isEmpty()) {
         RefPtrWillBeRawPtr<Event> event = eventQueue.takeFirst();
         Node* target = event->target()->toNode();
 
         // If the element was removed from our tree, also message the documentElement.
-        if (!target->inDocument() && document()->documentElement())
+        if (!target->inDocument() && document()->documentElement()) {
+            ASSERT(event->type() == EventTypeNames::webkitfullscreenchange || event->type() == EventTypeNames::webkitfullscreenerror);
             eventQueue.append(createEvent(event->type(), *document()->documentElement()));
+        }
 
         target->dispatchEvent(event);
     }
 }
 
 void FullscreenElementStack::fullScreenElementRemoved()
 {
     m_fullScreenElement->setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(false);
     fullyExitFullscreen();
 }
@@ skipping 23 matching lines @@
 }
 
 void FullscreenElementStack::popFullscreenElementStack()
 {
     if (m_fullScreenElementStack.isEmpty())
         return;
 
     m_fullScreenElementStack.removeLast();
 }
 
-void FullscreenElementStack::pushFullscreenElementStack(Element& element)
+void FullscreenElementStack::pushFullscreenElementStack(Element& element, RequestType requestType)
 {
-    m_fullScreenElementStack.append(&element);
+    m_fullScreenElementStack.append(std::make_pair(&element, requestType));
 }
 
 void FullscreenElementStack::trace(Visitor* visitor)
 {
     visitor->trace(m_fullScreenElement);
     visitor->trace(m_fullScreenElementStack);
     visitor->trace(m_fullScreenRenderer);
     visitor->trace(m_eventQueue);
     DocumentSupplement::trace(visitor);
 }
 
 } // namespace blink