Embedded media: Rotate to fullscreen

third_party/WebKit/Source/core/html/HTMLVideoElement.cpp

 /*
  * Copyright (C) 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 12 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/html/HTMLVideoElement.h"
 
 #include <memory>
 #include "bindings/core/v8/ExceptionState.h"
 #include "core/CSSPropertyNames.h"
 #include "core/HTMLNames.h"
 #include "core/dom/Attribute.h"
+#include "core/dom/ClientRect.h"
 #include "core/dom/Document.h"
+#include "core/dom/DocumentUserGestureToken.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/Fullscreen.h"
+#include "core/dom/ResizeObserver.h"
+#include "core/dom/ResizeObserverCallback.h"
+#include "core/dom/ResizeObserverEntry.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/frame/Settings.h"
 #include "core/html/MediaCustomControlsFullscreenDetector.h"
 #include "core/html/parser/HTMLParserIdioms.h"
 #include "core/imagebitmap/ImageBitmapOptions.h"
 #include "core/layout/LayoutImage.h"
 #include "core/layout/LayoutVideo.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/UserGestureIndicator.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/gpu/Extensions3DUtil.h"
 #include "public/platform/WebCanvas.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
+class HTMLVideoElementResizeObserverCallback final
+    : public ResizeObserverCallback {
+ public:
+  explicit HTMLVideoElementResizeObserverCallback(HTMLVideoElement* video)
+      : m_video(video), m_prevOrientationLandscape(false) {
+    DCHECK(video);
+  }
+
+  ~HTMLVideoElementResizeObserverCallback() override = default;
+
+  void handleEvent(const HeapVector<Member<ResizeObserverEntry>>& entries,
+                   ResizeObserver* observer) override {
+    if (!m_video->document().settings() ||
+        !m_video->document().settings()->getEmbeddedMediaExperienceEnabled())
+      return;
+
+    DCHECK_EQ(1u, entries.size());
+    float documentWidth = entries[0]->contentRect()->width();
+    float documentHeight = entries[0]->contentRect()->height();
+
+    if (!m_prevOrientationLandscape && documentWidth > documentHeight) {
+      UserGestureIndicator gesture(
+          DocumentUserGestureToken::create(&m_video->document()));
+      m_video->webkitEnterFullscreen();
+    }
+
+    m_prevOrientationLandscape = documentWidth > documentHeight;
+  }
+
+  DEFINE_INLINE_TRACE() {
+    visitor->trace(m_video);
+    ResizeObserverCallback::trace(visitor);
+  }
+
+ private:
+  Member<HTMLVideoElement> m_video;
+  bool m_prevOrientationLandscape;
+};
+
 inline HTMLVideoElement::HTMLVideoElement(Document& document)
-    : HTMLMediaElement(videoTag, document) {
+    : HTMLMediaElement(videoTag, document),
+      m_customControlsFullscreenDetector(
+          new MediaCustomControlsFullscreenDetector(*this)),
+      m_resizeObserver(ResizeObserver::create(
+          document,
+          new HTMLVideoElementResizeObserverCallback(this))) {
+  m_resizeObserver->observe(document.documentElement());
   if (document.settings()) {
     m_defaultPosterURL =
         AtomicString(document.settings()->getDefaultVideoPosterURL());
   }
 
   if (RuntimeEnabledFeatures::videoFullscreenDetectionEnabled()) {
     m_customControlsFullscreenDetector =
         new MediaCustomControlsFullscreenDetector(*this);
   }
 }
 
 HTMLVideoElement* HTMLVideoElement::create(Document& document) {
   HTMLVideoElement* video = new HTMLVideoElement(document);
   video->ensureUserAgentShadowRoot();
   video->suspendIfNeeded();
   return video;
 }
 
 DEFINE_TRACE(HTMLVideoElement) {
   visitor->trace(m_imageLoader);
   visitor->trace(m_customControlsFullscreenDetector);
+  visitor->trace(m_resizeObserver);
   HTMLMediaElement::trace(visitor);
 }
 
 void HTMLVideoElement::contextDestroyed(ExecutionContext* context) {
+  m_resizeObserver.clear();
   if (m_customControlsFullscreenDetector)
     m_customControlsFullscreenDetector->contextDestroyed();
 
   HTMLMediaElement::contextDestroyed(context);
 }
 
 bool HTMLVideoElement::layoutObjectIsNeeded(const ComputedStyle& style) {
   return HTMLElement::layoutObjectIsNeeded(style);
 }
 
@@ skipping 294 matching lines @@
     return ScriptPromise();
   if (!ImageBitmap::isResizeOptionValid(options, exceptionState))
     return ScriptPromise();
   return ImageBitmapSource::fulfillImageBitmap(
       scriptState,
       ImageBitmap::create(this, cropRect,
                           eventTarget.toLocalDOMWindow()->document(), options));
 }
 
 }  // namespace blink