IntersectionObserverCallbackImpl should use Member<ExecutionContext>

third_party/WebKit/Source/core/dom/IntersectionObserver.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 "core/dom/IntersectionObserver.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "core/css/parser/CSSParserTokenRange.h"
 #include "core/css/parser/CSSTokenizer.h"
 #include "core/dom/Element.h"
@@ skipping 36 matching lines @@
   }
 
   ExecutionContext* getExecutionContext() const override { return m_context; }
 
   DEFINE_INLINE_TRACE() {
     IntersectionObserverCallback::trace(visitor);
     visitor->trace(m_context);
   }
 
  private:
-  WeakMember<ExecutionContext> m_context;
+  Member<ExecutionContext> m_context;

[sof, 2016/12/26 07:28:04]

The use of WeakMember<> comes from


https://codereview.chromium.org/2051253002/diff/100001/third_party/WebKit/Sou...

not much discussion associated with it. If there are problems here with keeping
a strong reference, they'd be leaks.

   std::unique_ptr<IntersectionObserver::EventCallback> m_callback;
 };
 
 void parseRootMargin(String rootMarginParameter,
                      Vector<Length>& rootMargin,
                      ExceptionState& exceptionState) {
   // TODO(szager): Make sure this exact syntax and behavior is spec-ed
   // somewhere.
 
   // The root margin argument accepts syntax similar to that for CSS margin:
@@ skipping 147 matching lines @@
   m_root = nullptr;
 }
 
 bool IntersectionObserver::rootIsValid() const {
   return rootIsImplicit() || root();
 }
 
 Document& IntersectionObserver::trackingDocument() const {
   Document* document = nullptr;
   if (rootIsImplicit()) {
-    DCHECK(m_callback->getExecutionContext());
     document = toDocument(m_callback->getExecutionContext());
   } else {
     DCHECK(root());
     document = &root()->document();
   }
   DCHECK(document);
   DCHECK(document->frame());
   return *document->frame()->localFrameRoot()->document();
 }
 
@@ skipping 67 matching lines @@
     return;
 
   if (IntersectionObservation* observation =
           target->intersectionObserverData()->getObservationFor(*this))
     observation->disconnect();
 }
 
 void IntersectionObserver::computeIntersectionObservations() {
   if (!rootIsValid())
     return;
-  Document* callbackDocument = toDocument(m_callback->getExecutionContext());
-  if (!callbackDocument)
-    return;
-  LocalDOMWindow* callbackDOMWindow = callbackDocument->domWindow();
+  LocalDOMWindow* callbackDOMWindow =
+      toDocument(m_callback->getExecutionContext())->domWindow();
   if (!callbackDOMWindow)
     return;
   DOMHighResTimeStamp timestamp =
       DOMWindowPerformance::performance(*callbackDOMWindow)->now();
   for (auto& observation : m_observations)
     observation->computeIntersectionObservations(timestamp);
 }
 
 void IntersectionObserver::disconnect(ExceptionState& exceptionState) {
   if (!rootIsValid()) {
@@ skipping 80 matching lines @@
 
 DEFINE_TRACE(IntersectionObserver) {
   visitor->template registerWeakMembers<
       IntersectionObserver, &IntersectionObserver::clearWeakMembers>(this);
   visitor->trace(m_callback);
   visitor->trace(m_observations);
   visitor->trace(m_entries);
 }
 
 }  // namespace blink