Sync requestFullscreen() and exitFullscreen() algorithms with the spec

third_party/WebKit/Source/core/dom/Fullscreen.h

 /*
  * 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)
@@ skipping 17 matching lines @@
  */
 
 #ifndef Fullscreen_h
 #define Fullscreen_h
 
 #include "core/CoreExport.h"
 #include "core/dom/ContextLifecycleObserver.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "platform/Supplementable.h"
-#include "platform/Timer.h"
 #include "platform/geometry/LayoutRect.h"
 #include "wtf/Deque.h"
 #include "wtf/RefPtr.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 
 class ComputedStyle;
 class LayoutFullScreen;
 
 class CORE_EXPORT Fullscreen final
     : public GarbageCollectedFinalized<Fullscreen>,
       public Supplement<Document>,
       public ContextLifecycleObserver {
   USING_GARBAGE_COLLECTED_MIXIN(Fullscreen);
 
  public:
   virtual ~Fullscreen();
   static const char* supplementName();
   static Fullscreen& from(Document&);
   static Fullscreen* fromIfExists(Document&);
   static Element* fullscreenElementFrom(Document&);
   static Element* fullscreenElementForBindingFrom(TreeScope&);
-  static Element* currentFullScreenElementFrom(Document&);
-  static Element* currentFullScreenElementForBindingFrom(Document&);
-  static bool isCurrentFullScreenElement(const Element&);
+  static size_t fullscreenElementStackSizeFrom(Document&);
+  static bool isFullscreenElement(const Element&);
 
   enum class RequestType {
     // Element.requestFullscreen()
     Unprefixed,
     // Element.webkitRequestFullscreen()/webkitRequestFullScreen() and
     // HTMLVideoElement.webkitEnterFullscreen()/webkitEnterFullScreen()
     Prefixed,
+    // For WebRemoteFrameImpl to notify that a cross-process descendant frame
+    // has requested and is about to enter fullscreen.
+    PrefixedForCrossProcessDescendant,

[alexmos, 2016/12/15 07:58:53]

When we add plumbing for the request type in OOPIF fullscreen requests (in
willEnterFullscreen), seems like we will end up adding an
UnprefixedForCrossProcessDescendant here, and having to check for that in
addition to Unprefixed in places like createChangeEvent.  Was that how you
wanted to do that eventually?  I guess if we kept the forCrossProcessDescendant
bit separate from this, that would also need to be in the fullscreen element
stack, which seems ugly.

FWIW, I started working on a CL for plumbing the request type for OOPIFs a while
back, but got distracted with other things before finishing.  We should figure
out how to finish it before unprefixed fullscreen ships - when do you think that
might happen?

[foolip, 2016/12/19 17:36:57]

Having both bits of information in RequestType was nifty and indeed the reason I
did this. Rather than adding UnprefixedForCrossProcessDescendant I think this
will have to be turned into a bitfield of size two to represent all four
combinations.

I'll be OOO until January, but I hope to ship unprefixed fullscreen in M57 or
M58, so we'll have to revisit this soon. (First though, moving to top layer.
Getting rid of :-webkit-full-screen-ancestor would also simplify things a bit,
and it's not clear yet if that'll happen before unprefixing.)

   };
 
   static void requestFullscreen(Element&);
-
-  // |forCrossProcessDescendant| is used in OOPIF scenarios and is set to
-  // true when fullscreen is requested for an out-of-process descendant
-  // element.
-  static void requestFullscreen(Element&,
-                                RequestType,
-                                bool forCrossProcessDescendant = false);
+  static void requestFullscreen(Element&, RequestType);
 
   static void fullyExitFullscreen(Document&);
-  static void exitFullscreen(Document&);
+
+  enum class ExitType {
+    // Exits fullscreen for one element in the document.
+    Default,
+    // Fully exits fullscreen for the document.
+    Fully,
+  };
+
+  static void exitFullscreen(Document&, ExitType = ExitType::Default);
 
   static bool fullscreenEnabled(Document&);
-  // TODO(foolip): The fullscreen element stack is modified synchronously in
-  // requestFullscreen(), which is not per spec and means that
-  // |fullscreenElement()| is not always the same as
-  // |currentFullScreenElement()|, see https://crbug.com/402421.
   Element* fullscreenElement() const {
     return !m_fullscreenElementStack.isEmpty()
                ? m_fullscreenElementStack.back().first.get()
                : nullptr;
   }
 
   // Called by FullscreenController to notify that we've entered or exited
   // fullscreen. All frames are notified, so there may be no pending request.
   void didEnterFullscreen();
   void didExitFullscreen();
 
   void setFullScreenLayoutObject(LayoutFullScreen*);
   LayoutFullScreen* fullScreenLayoutObject() const {
     return m_fullScreenLayoutObject;
   }
   void fullScreenLayoutObjectDestroyed();
 
   void elementRemoved(Element&);
 
-  // Returns true if the current fullscreen element stack corresponds to a
-  // container for an actual fullscreen element in a descendant
-  // out-of-process iframe.
-  bool forCrossProcessDescendant() { return m_forCrossProcessDescendant; }

[alexmos, 2016/12/15 07:58:53]

See my note in FullscreenController::enterFullscreen about this.

-
-  // Mozilla API
-  // TODO(foolip): |currentFullScreenElement()| is a remnant from before the
-  // fullscreen element stack. It is still maintained separately from the
-  // stack and is is what the :-webkit-full-screen pseudo-class depends on. It
-  // should be removed, see https://crbug.com/402421.
-  Element* currentFullScreenElement() const {
-    return m_currentFullScreenElement.get();
-  }
-
   // ContextLifecycleObserver:
   void contextDestroyed() override;
 
   DECLARE_VIRTUAL_TRACE();
 
  private:
   static Fullscreen* fromIfExistsSlow(Document&);
 
   explicit Fullscreen(Document&);
 
   Document* document();
 
+  static void enqueueTaskForRequest(Document&,
+                                    Element&,
+                                    RequestType,
+                                    bool error);
+  static void runTaskForRequest(Document*, Element*, RequestType, bool error);
+
+  static void enqueueTaskForExit(Document&, ExitType);
+  static void runTaskForExit(Document*, ExitType);
+
   void clearFullscreenElementStack();
   void popFullscreenElementStack();
   void pushFullscreenElementStack(Element&, RequestType);
+  void fullscreenElementChanged(Element*, Element*, RequestType);

[mlamouri (slow - plz ping), 2016/12/14 16:24:12]

I would name the two different `Element*` parameters here because otherwise one
has to guess it is old/new unless they look at the implementation.

[foolip, 2016/12/19 17:36:57]

Done, all args named. (I imitated ChromeClient::focusedNodeChanged, but guessing
RequestType is even harder than the from/to element.)

 
-  void enqueueChangeEvent(Document&, RequestType);
-  void enqueueErrorEvent(Element&, RequestType);
-  void eventQueueTimerFired(TimerBase*);
+  using ElementStackEntry = std::pair<Member<Element>, RequestType>;
+  using ElementStack = HeapVector<ElementStackEntry>;
+  ElementStack m_pendingRequests;
+  ElementStack m_fullscreenElementStack;
 
-  Member<Element> m_pendingFullscreenElement;
-  HeapVector<std::pair<Member<Element>, RequestType>> m_fullscreenElementStack;
-  Member<Element> m_currentFullScreenElement;
   LayoutFullScreen* m_fullScreenLayoutObject;
-  Timer<Fullscreen> m_eventQueueTimer;
-  HeapDeque<Member<Event>> m_eventQueue;
   LayoutRect m_savedPlaceholderFrameRect;
   RefPtr<ComputedStyle> m_savedPlaceholderComputedStyle;
-
-  // TODO(alexmos, dcheng): Currently, this assumes that if fullscreen was
-  // entered for an element in an out-of-process iframe, then it's not
-  // possible to re-enter fullscreen for a different element in this
-  // document, since that requires a user gesture, which can't be obtained
-  // since nothing in this document is visible, and since user gestures can't
-  // be forwarded across processes. However, the latter assumption could
-  // change if https://crbug.com/161068 is fixed so that cross-process
-  // postMessage can carry user gestures.  If that happens, this should be
-  // moved to be part of |m_fullscreenElementStack|.
-  bool m_forCrossProcessDescendant;
 };
 
 inline Fullscreen* Fullscreen::fromIfExists(Document& document) {
   if (!document.hasFullscreenSupplement())
     return nullptr;
   return fromIfExistsSlow(document);
 }
 
-inline bool Fullscreen::isCurrentFullScreenElement(const Element& element) {
+inline bool Fullscreen::isFullscreenElement(const Element& element) {
   if (Fullscreen* found = fromIfExists(element.document()))
-    return found->currentFullScreenElement() == &element;
+    return found->fullscreenElement() == &element;
   return false;
 }
 
 }  // namespace blink
 
 #endif  // Fullscreen_h