VRDisplay inherits from EventTarget

third_party/WebKit/Source/modules/vr/VRDisplay.cpp

 // Copyright 2016 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 "modules/vr/VRDisplay.h"
 
 #include "core/css/StylePropertySet.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/DocumentUserGestureToken.h"
 #include "core/dom/FrameRequestCallback.h"
 #include "core/dom/Fullscreen.h"
 #include "core/dom/ScriptedAnimationController.h"
 #include "core/frame/UseCounter.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/loader/DocumentLoader.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
+#include "modules/EventTargetModules.h"
 #include "modules/vr/NavigatorVR.h"
 #include "modules/vr/VRController.h"
 #include "modules/vr/VRDisplayCapabilities.h"
 #include "modules/vr/VREyeParameters.h"
 #include "modules/vr/VRFrameData.h"
 #include "modules/vr/VRLayer.h"
 #include "modules/vr/VRPose.h"
 #include "modules/vr/VRStageParameters.h"
 #include "modules/webgl/WebGLRenderingContextBase.h"
 #include "platform/Histogram.h"
@@ skipping 44 matching lines @@
   }
 
   Member<VRDisplay> m_vrDisplay;
 };
 
 }  // namespace
 
 VRDisplay::VRDisplay(NavigatorVR* navigatorVR,
                      device::mojom::blink::VRDisplayPtr display,
                      device::mojom::blink::VRDisplayClientRequest request)
-    : m_navigatorVR(navigatorVR),
+    : ActiveScriptWrappable(this),
+      ContextLifecycleObserver(navigatorVR->document()),
+      m_navigatorVR(navigatorVR),
       m_isConnected(false),
       m_isPresenting(false),
       m_isValidDeviceForPresenting(true),
       m_canUpdateFramePose(true),
       m_capabilities(new VRDisplayCapabilities()),
       m_eyeParametersLeft(new VREyeParameters()),
       m_eyeParametersRight(new VREyeParameters()),
       m_depthNear(0.01),
       m_depthFar(10000.0),
       m_fullscreenCheckTimer(this, &VRDisplay::onFullscreenCheck),
@@ skipping 107 matching lines @@
     case VREyeLeft:
       return m_eyeParametersLeft;
     case VREyeRight:
       return m_eyeParametersRight;
     default:
       return nullptr;
   }
 }
 
 int VRDisplay::requestAnimationFrame(FrameRequestCallback* callback) {
-  Document* doc = m_navigatorVR->document();
+  Document* doc = this->document();
   if (!doc)
     return 0;
 
   if (!m_animationCallbackRequested) {
     doc->requestAnimationFrame(new VRDisplayFrameRequestCallback(this));
     m_animationCallbackRequested = true;
   }
 
   callback->m_useLegacyTimeBase = false;
   return ensureScriptedAnimationController(doc).registerCallback(callback);
@@ skipping 13 matching lines @@
 }
 
 void VRDisplay::OnFocus() {
   m_displayBlurred = false;
   // Restart our internal doc requestAnimationFrame callback, if it fired while
   // the display was blurred.
   // TODO(bajones): Don't use doc->requestAnimationFrame() at all. Animation
   // frames should be tied to the presenting VR display (e.g. should be serviced
   // by GVR library callbacks on Android), and not the doc frame rate.
   if (!m_animationCallbackRequested) {
-    Document* doc = m_navigatorVR->document();
+    Document* doc = this->document();
     if (!doc)
       return;
     doc->requestAnimationFrame(new VRDisplayFrameRequestCallback(this));
   }
   m_navigatorVR->enqueueVREvent(VRDisplayEvent::create(
       EventTypeNames::vrdisplayfocus, true, false, this, ""));
 }
 
 void VRDisplay::serviceScriptedAnimations(double monotonicAnimationStartTime) {
   if (!m_scriptedAnimationController)
@@ skipping 175 matching lines @@
   m_display->ExitPresent();
 
   resolver->resolve();
 
   forceExitPresent();
 
   return promise;
 }
 
 void VRDisplay::beginPresent() {
-  Document* doc = m_navigatorVR->document();
+  Document* doc = this->document();
   std::unique_ptr<UserGestureIndicator> gestureIndicator;
   if (m_capabilities->hasExternalDisplay()) {
     forceExitPresent();
     DOMException* exception = DOMException::create(
         InvalidStateError,
         "VR Presentation not implemented for this VRDisplay.");
     while (!m_pendingPresentResolvers.isEmpty()) {
       ScriptPromiseResolver* resolver = m_pendingPresentResolvers.takeFirst();
       resolver->reject(exception);
     }
@@ skipping 134 matching lines @@
     layers.append(m_layer);
   }
 
   return layers;
 }
 
 void VRDisplay::submitFrame() {
   if (!m_display)
     return;
 
-  Document* doc = m_navigatorVR->document();
+  Document* doc = this->document();
   if (!m_isPresenting) {
     if (doc) {
       doc->addConsoleMessage(ConsoleMessage::create(
           RenderingMessageSource, WarningMessageLevel,
           "submitFrame has no effect when the VRDisplay is not presenting."));
     }
     return;
   }
 
   if (!m_inAnimationFrame) {
@@ skipping 106 matching lines @@
     if (m_reenteredFullscreen) {
       m_isPresenting = false;
       OnPresentChange();
       m_fullscreenCheckTimer.stop();
       if (m_display)
         m_display->ExitPresent();
       return;
     }
     m_reenteredFullscreen = true;
     auto canvas = m_layer.source();
-    Document* doc = m_navigatorVR->document();
+    Document* doc = this->document();
     std::unique_ptr<UserGestureIndicator> gestureIndicator;
     if (doc) {
       gestureIndicator =
           wrapUnique(new UserGestureIndicator(DocumentUserGestureToken::create(
               doc, UserGestureToken::Status::PossiblyExistingGesture)));
     }
     Fullscreen::requestFullscreen(*canvas, Fullscreen::UnprefixedRequest);
   }
 }
 
 ScriptedAnimationController& VRDisplay::ensureScriptedAnimationController(
     Document* doc) {
   if (!m_scriptedAnimationController)
     m_scriptedAnimationController = ScriptedAnimationController::create(doc);
 
   return *m_scriptedAnimationController;
 }
 
 void VRDisplay::dispose() {
   m_binding.Close();
 }
 
+ExecutionContext* VRDisplay::getExecutionContext() const {
+  return ContextLifecycleObserver::getExecutionContext();
+}
+
+const AtomicString& VRDisplay::interfaceName() const {
+  return EventTargetNames::VRDisplay;
+}
+
+void VRDisplay::contextDestroyed() {
+  forceExitPresent();
+  ContextLifecycleObserver::clearContext();

[haraken, 2016/12/07 09:01:22]

This won't be needed. ContextLifecycleObserver clears the context after calling
all contextDestroyed().

+}
+
+bool VRDisplay::hasPendingActivity() const {
+  // Prevent V8 from garbage collecting the wrapper object if there are
+  // event listeners attached to it.
+  return hasEventListeners();

[haraken, 2016/12/07 09:01:22]

Would you change this to:

  return getExecutionContext() && hasEventListeners();

?

Currently the wrapper tracing doesn't have logic to ignore pending activities on
a detached context (we're fixing it now). So the caller side needs to take care
of it.

+}
+
 DEFINE_TRACE(VRDisplay) {
+  EventTargetWithInlineData::trace(visitor);
+  ContextLifecycleObserver::trace(visitor);
   visitor->trace(m_navigatorVR);
   visitor->trace(m_capabilities);
   visitor->trace(m_stageParameters);
   visitor->trace(m_eyeParametersLeft);
   visitor->trace(m_eyeParametersRight);
   visitor->trace(m_layer);
   visitor->trace(m_renderingContext);
   visitor->trace(m_scriptedAnimationController);
   visitor->trace(m_pendingPresentResolvers);
 }
 
 }  // namespace blink