Set fullscreenEnabled to false when fullscreen is not supported.

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 39 matching lines @@
 {
     for (const HTMLFrameOwnerElement* owner = document.ownerElement(); owner; owner = owner->document().ownerElement()) {
         if (!isHTMLIFrameElement(owner))
             return false;
         if (!owner->hasAttribute(allowfullscreenAttr))
             return false;
     }
     return true;
 }
 
+static bool fullscreenIsSupported(const Document& document, const Element* element)

[philipj_slow, 2014/08/04 09:24:13]

I think this would be slightly nicer with separate
fullscreenIsSupported(Document&) and fullscreenIsSupported(Element&), where the
latter uses the former. Less conversion between pointers and references, at
least.

[Ignacio Solla, 2014/08/04 11:43:33]

Done.

+{
+    // Fullscreen is supported if there is no previously-established user preference,
+    // security risk, or platform limitation.
+    if (element && document.settings()->disallowFullscreenForNonMediaElements() && !isHTMLMediaElement(*element))
+        return false;
+    return document.settings()->fullscreenEnabled();
+}
+
 static PassRefPtrWillBeRawPtr<Event> createEvent(const AtomicString& type, EventTarget& target)
 {
     RefPtrWillBeRawPtr<Event> event = Event::createBubble(type);
     event->setTarget(&target);
     return event;
 }
 
 const char* FullscreenElementStack::supplementName()
 {
     return "FullscreenElementStack";
@@ skipping 136 matching lines @@
                 break;
         }
 
         // This algorithm is not allowed to show a pop-up:
         //   An algorithm is allowed to show a pop-up if, in the task in which the algorithm is running, either:
         //   - an activation behavior is currently being processed whose click event was trusted, or
         //   - the event listener for a trusted click event is being handled.
         if (!UserGestureIndicator::processingUserGesture())
             break;
 
-        // There is a previously-established user preference, security risk, or platform limitation.
-        if (!document()->settings()->fullscreenEnabled())
-            break;
-        if (document()->settings()->disallowFullscreenForNonMediaElements() && !isHTMLMediaElement(element))
+        // Fullscreen is not supported.
+        if (!fullscreenIsSupported(element.document(), &element))
             break;
 
         // 2. Let doc be element's node document. (i.e. "this")
         Document* currentDoc = document();
 
         // 3. Let docs be all doc's ancestor browsing context's documents (if any) and doc.
         Deque<Document*> docs;
 
         do {
             docs.prepend(currentDoc);
@@ skipping 140 matching lines @@
         host->chrome().client().exitFullScreenForElement(m_fullScreenElement.get());
         return;
     }
 
     // Otherwise, notify the chrome of the new full screen element.
     host->chrome().client().enterFullScreenForElement(newTop);
 }
 
 bool FullscreenElementStack::fullscreenEnabled(Document& document)
 {
-    // 4. The fullscreenEnabled attribute must return true if the context object and all ancestor
-    // browsing context's documents have their fullscreen enabled flag set, or false otherwise.
+    // 4. The fullscreenEnabled attribute must return true if the context object has its
+    //    fullscreen enabled flag set and fullscreen is supported, and false otherwise.
 
     // Top-level browsing contexts are implied to have their allowFullScreen attribute set.
-    return fullscreenIsAllowedForAllOwners(document);
+    return fullscreenIsAllowedForAllOwners(document) && fullscreenIsSupported(document, 0);
 }
 
 void FullscreenElementStack::willEnterFullScreenForElement(Element* element)
 {
     ASSERT(element);
     if (!document()->isActive())
         return;
 
     if (m_fullScreenRenderer)
         m_fullScreenRenderer->unwrapRenderer();
@@ skipping 183 matching lines @@
 
 void FullscreenElementStack::trace(Visitor* visitor)
 {
     visitor->trace(m_fullScreenElement);
     visitor->trace(m_fullScreenElementStack);
     visitor->trace(m_eventQueue);
     DocumentSupplement::trace(visitor);
 }
 
 } // namespace blink