Changeset 242058 in webkit


Ignore:
Timestamp:
Feb 25, 2019 3:11:19 PM (5 years ago)
Author:
Alan Bujtas
Message:

[ContentChangeObserver] Move observing logic from DOMTimer to ContentChangeObserver
https://bugs.webkit.org/show_bug.cgi?id=194987
<rdar://problem/48342910>

Reviewed by Tim Horton.

Content obvservation logic should all move to the ContentChangeObserver class.

  • page/DOMTimer.cpp:

(WebCore::DOMTimer::install):
(WebCore::DOMTimer::fired):

  • page/Page.cpp:

(WebCore::Page::Page):

  • page/Page.h:

(WebCore::Page::contentChangeObserver):

  • page/ios/ContentChangeObserver.h:
  • page/ios/ContentChangeObserver.mm:

(WebCore::ContentChangeObserver::ContentChangeObserver):
(WebCore::ContentChangeObserver::registerDOMTimerForContentObservationIfNeeded):
(WebCore::ContentChangeObserver::startObservingDOMTimer):
(WebCore::ContentChangeObserver::stopObservingDOMTimer):
(WebCore::ContentChangeObserver::containsObservedDOMTimer):
(WebCore::ContentChangeObserver::addObservedDOMTimer):
(WebCore::ContentChangeObserver::removeObservedDOMTimer):

Location:
trunk/Source/WebCore
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r242056 r242058  
     12019-02-25  Zalan Bujtas  <zalan@apple.com>
     2
     3        [ContentChangeObserver] Move observing logic from DOMTimer to ContentChangeObserver
     4        https://bugs.webkit.org/show_bug.cgi?id=194987
     5        <rdar://problem/48342910>
     6
     7        Reviewed by Tim Horton.
     8
     9        Content obvservation logic should all move to the ContentChangeObserver class.
     10
     11        * page/DOMTimer.cpp:
     12        (WebCore::DOMTimer::install):
     13        (WebCore::DOMTimer::fired):
     14        * page/Page.cpp:
     15        (WebCore::Page::Page):
     16        * page/Page.h:
     17        (WebCore::Page::contentChangeObserver):
     18        * page/ios/ContentChangeObserver.h:
     19        * page/ios/ContentChangeObserver.mm:
     20        (WebCore::ContentChangeObserver::ContentChangeObserver):
     21        (WebCore::ContentChangeObserver::registerDOMTimerForContentObservationIfNeeded):
     22        (WebCore::ContentChangeObserver::startObservingDOMTimer):
     23        (WebCore::ContentChangeObserver::stopObservingDOMTimer):
     24        (WebCore::ContentChangeObserver::containsObservedDOMTimer):
     25        (WebCore::ContentChangeObserver::addObservedDOMTimer):
     26        (WebCore::ContentChangeObserver::removeObservedDOMTimer):
     27
    1282019-02-25  John Wilander  <wilander@apple.com>
    229
  • trunk/Source/WebCore/page/DOMTimer.cpp

    r242041 r242058  
    4343
    4444#if PLATFORM(IOS_FAMILY)
    45 #include "Chrome.h"
    46 #include "ChromeClient.h"
    4745#include "ContentChangeObserver.h"
    48 #include "Frame.h"
    4946#endif
    5047
     
    225222    if (NestedTimersMap* nestedTimers = NestedTimersMap::instanceForContext(context))
    226223        nestedTimers->add(timer->m_timeoutId, *timer);
    227 
    228224#if PLATFORM(IOS_FAMILY)
    229     auto startObservingThisTimerIfNeeded = [&] {
    230         if (!is<Document>(context))
    231             return;
    232         if (context.activeDOMObjectsAreSuspended())
    233             return;
    234         if (timeout > 250_ms || !singleShot)
    235             return;
    236         auto& contentChangeObserver = downcast<Document>(context).page()->contentChangeObserver();
    237         if (!contentChangeObserver.isObservingDOMTimerScheduling())
    238             return;
    239 
    240         contentChangeObserver.setObservedContentChange(WKContentIndeterminateChange);
    241         contentChangeObserver.addObservedDOMTimer(*timer);
    242         LOG_WITH_STREAM(ContentObservation, stream << "DOMTimer::install: register this timer: (" << timer->m_timeoutId << ") and observe when it fires.");
    243     };
    244 
    245     startObservingThisTimerIfNeeded();
     225    if (is<Document>(context))
     226        downcast<Document>(context).page()->contentChangeObserver().registerDOMTimerForContentObservationIfNeeded(*timer, timeout, singleShot);
    246227#endif
    247228    return timer->m_timeoutId;
     
    349330    context.removeTimeout(m_timeoutId);
    350331
    351 #if PLATFORM(IOS_FAMILY)
    352     auto isObservingLastTimer = false;
    353     auto shouldBeginObservingChanges = false;
    354     Page* page = nullptr;
    355     if (is<Document>(context) && downcast<Document>(context).page()) {
    356         page = downcast<Document>(context).page();
    357         auto& contentChangeObserver = page->contentChangeObserver();
    358         isObservingLastTimer = contentChangeObserver.countOfObservedDOMTimers() == 1;
    359         shouldBeginObservingChanges = contentChangeObserver.containsObservedDOMTimer(*this);
    360     }
    361 
    362     if (shouldBeginObservingChanges) {
    363         ASSERT(page);
    364         LOG_WITH_STREAM(ContentObservation, stream << "DOMTimer::fired: start observing (" << m_timeoutId << ") timer callback.");
    365         auto& contentChangeObserver = page->contentChangeObserver();
    366         contentChangeObserver.startObservingContentChanges();
    367         contentChangeObserver.startObservingStyleRecalcScheduling();
    368         contentChangeObserver.removeObservedDOMTimer(*this);
    369     }
    370 #endif
    371 
    372332    // Keep track nested timer installs.
    373333    NestedTimersMap* nestedTimers = NestedTimersMap::instanceForContext(context);
     
    375335        nestedTimers->startTracking();
    376336
     337#if PLATFORM(IOS_FAMILY)
     338    Page* page = is<Document>(context) ? downcast<Document>(context).page() : nullptr;
     339    if (page)
     340        page->contentChangeObserver().startObservingDOMTimerExecute(*this);
     341#endif
    377342    m_action->execute(context);
    378 
    379343#if PLATFORM(IOS_FAMILY)
    380     if (shouldBeginObservingChanges) {
    381         ASSERT(page);
    382         LOG_WITH_STREAM(ContentObservation, stream << "DOMTimer::fired: stop observing (" << m_timeoutId << ") timer callback.");
    383         auto& contentChangeObserver = page->contentChangeObserver();
    384         contentChangeObserver.stopObservingStyleRecalcScheduling();
    385         contentChangeObserver.stopObservingContentChanges();
    386 
    387         auto observedContentChange = contentChangeObserver.observedContentChange();
    388         // Check if the timer callback triggered either a sync or async style update.
    389         auto inDeterminedState = observedContentChange == WKContentVisibilityChange || (isObservingLastTimer && observedContentChange == WKContentNoChange); 
    390         if (inDeterminedState) {
    391             LOG_WITH_STREAM(ContentObservation, stream << "DOMTimer::fired(" << m_timeoutId << "): in determined state.");
    392             page->chrome().client().observedContentChange(*downcast<Document>(context).frame());
    393         } else if (observedContentChange == WKContentIndeterminateChange) {
    394             // An async style recalc has been scheduled. Let's observe it.
    395             LOG_WITH_STREAM(ContentObservation, stream << "DOMTimer::fired(" << m_timeoutId << "): wait until next style recalc fires.");
    396             contentChangeObserver.setShouldObserveNextStyleRecalc(true);
    397         }
    398     }
     344    if (page)
     345        page->contentChangeObserver().stopObservingDOMTimerExecute(*this);
    399346#endif
    400347
  • trunk/Source/WebCore/page/Page.cpp

    r242056 r242058  
    150150#endif
    151151
     152#if PLATFORM(IOS_FAMILY)
     153#include "ContentChangeObserver.h"
     154#endif
     155
    152156namespace WebCore {
    153157
     
    232236    , m_webGLStateTracker(WTFMove(pageConfiguration.webGLStateTracker))
    233237    , m_libWebRTCProvider(WTFMove(pageConfiguration.libWebRTCProvider))
     238#if PLATFORM(IOS_FAMILY)
     239    , m_contentChangeObserver(std::make_unique<ContentChangeObserver>(*this))
     240#endif
    234241    , m_verticalScrollElasticity(ScrollElasticityAllowed)
    235242    , m_horizontalScrollElasticity(ScrollElasticityAllowed)
  • trunk/Source/WebCore/page/Page.h

    r242056 r242058  
    6868#endif
    6969
    70 #if PLATFORM(IOS_FAMILY)
    71 #include "ContentChangeObserver.h"
    72 #endif
    73 
    7470namespace JSC {
    7571class Debugger;
     
    9187class ChromeClient;
    9288class Color;
     89#if PLATFORM(IOS_FAMILY)
     90class ContentChangeObserver;
     91#endif
    9392class ContextMenuClient;
    9493class ContextMenuController;
     
    258257#endif
    259258#if PLATFORM(IOS_FAMILY)
    260     ContentChangeObserver& contentChangeObserver() { return m_contentChangeObserver; }
     259    ContentChangeObserver& contentChangeObserver() { return *m_contentChangeObserver; }
    261260#endif
    262261    LibWebRTCProvider& libWebRTCProvider() { return m_libWebRTCProvider.get(); }
     
    817816#if PLATFORM(IOS_FAMILY)
    818817    bool m_enclosedInScrollableAncestorView { false };
    819     ContentChangeObserver m_contentChangeObserver;
     818    std::unique_ptr<ContentChangeObserver> m_contentChangeObserver;
    820819#endif
    821820   
  • trunk/Source/WebCore/page/ios/ContentChangeObserver.h

    r242032 r242058  
    3333
    3434class DOMTimer;
     35class Page;
    3536
    3637class ContentChangeObserver {
    3738public:
    38     ContentChangeObserver() = default;
     39    ContentChangeObserver(Page&);
     40
     41    void registerDOMTimerForContentObservationIfNeeded(const DOMTimer&, Seconds timeout, bool singleShot);
     42    void startObservingDOMTimerExecute(const DOMTimer&);
     43    void stopObservingDOMTimerExecute(const DOMTimer&);
    3944
    4045    WEBCORE_EXPORT void startObservingContentChanges();
     
    4449    WEBCORE_EXPORT void startObservingDOMTimerScheduling();
    4550    WEBCORE_EXPORT void stopObservingDOMTimerScheduling();
    46     bool isObservingDOMTimerScheduling();
    4751
    48     WEBCORE_EXPORT void startObservingStyleRecalcScheduling();
    49     WEBCORE_EXPORT void stopObservingStyleRecalcScheduling();
    5052    bool isObservingStyleRecalcScheduling();
    5153
     
    5658    WEBCORE_EXPORT WKContentChange observedContentChange();
    5759
    58     void addObservedDOMTimer(DOMTimer&);
    59     void removeObservedDOMTimer(DOMTimer&);
    60     bool containsObservedDOMTimer(DOMTimer&);
     60    void removeObservedDOMTimer(const DOMTimer&);
     61    bool containsObservedDOMTimer(const DOMTimer&);
    6162    WEBCORE_EXPORT unsigned countOfObservedDOMTimers();
    6263    WEBCORE_EXPORT void clearObservedDOMTimers();
     64
     65private:
     66    void addObservedDOMTimer(const DOMTimer&);
     67    bool isObservingDOMTimerScheduling();
     68
     69    void startObservingStyleRecalcScheduling();
     70    void stopObservingStyleRecalcScheduling();
     71
     72    Page& m_page;
    6373};
    6474
  • trunk/Source/WebCore/page/ios/ContentChangeObserver.mm

    r242032 r242058  
    2727
    2828#if PLATFORM(IOS_FAMILY)
     29#import "Chrome.h"
     30#import "ChromeClient.h"
    2931#import "DOMTimer.h"
     32#import "Logging.h"
     33#import "Page.h"
    3034#import "WKContentObservationInternal.h"
    3135
    3236namespace WebCore {
     37
     38ContentChangeObserver::ContentChangeObserver(Page& page)
     39    : m_page(page)
     40{
     41}
     42
     43void ContentChangeObserver::registerDOMTimerForContentObservationIfNeeded(const DOMTimer& timer, Seconds timeout, bool singleShot)
     44{
     45    if (!m_page.mainFrame().document())
     46        return;
     47    if (m_page.mainFrame().document()->activeDOMObjectsAreSuspended())
     48        return;
     49    if (timeout > 250_ms || !singleShot)
     50        return;
     51    if (!isObservingDOMTimerScheduling())
     52        return;
     53    setObservedContentChange(WKContentIndeterminateChange);
     54    addObservedDOMTimer(timer);
     55    LOG_WITH_STREAM(ContentObservation, stream << "registerDOMTimerForContentObservationIfNeeded: registed this timer: (" << &timer << ") and observe when it fires.");
     56}
     57
     58void ContentChangeObserver::startObservingDOMTimerExecute(const DOMTimer& timer)
     59{
     60    if (!containsObservedDOMTimer(timer))
     61        return;
     62    LOG_WITH_STREAM(ContentObservation, stream << "startObservingDOMTimerExecute: start observing (" << &timer << ") timer callback.");
     63    startObservingContentChanges();
     64    startObservingStyleRecalcScheduling();
     65}
     66
     67void ContentChangeObserver::stopObservingDOMTimerExecute(const DOMTimer& timer)
     68{
     69    if (!containsObservedDOMTimer(timer))
     70        return;
     71    removeObservedDOMTimer(timer);
     72    stopObservingStyleRecalcScheduling();
     73    stopObservingContentChanges();
     74    auto observedContentChange = this->observedContentChange();
     75    // Check if the timer callback triggered either a sync or async style update.
     76    auto inDeterminedState = observedContentChange == WKContentVisibilityChange || (!countOfObservedDOMTimers() && observedContentChange == WKContentNoChange); 
     77
     78    LOG_WITH_STREAM(ContentObservation, stream << "stopObservingDOMTimerExecute: stop observing (" << &timer << ") timer callback.");
     79    if (inDeterminedState) {
     80        LOG_WITH_STREAM(ContentObservation, stream << "stopObservingDOMTimerExecute: (" << &timer << ") in determined state.");
     81        m_page.chrome().client().observedContentChange(m_page.mainFrame());
     82    } else if (observedContentChange == WKContentIndeterminateChange) {
     83        // An async style recalc has been scheduled. Let's observe it.
     84        LOG_WITH_STREAM(ContentObservation, stream << "stopObservingDOMTimerExecute: (" << &timer << ") wait until next style recalc fires.");
     85        setShouldObserveNextStyleRecalc(true);
     86    }
     87}
    3388
    3489void ContentChangeObserver::startObservingContentChanges()
     
    3994void ContentChangeObserver::stopObservingContentChanges()
    4095{
    41     WKStopObservingContentChanges();   
     96    WKStopObservingContentChanges();
    4297}
    4398
    4499bool ContentChangeObserver::isObservingContentChanges()
    45100{
    46     return WKObservingContentChanges();   
     101    return WKObservingContentChanges();
    47102}
    48103
     
    107162}
    108163
    109 bool ContentChangeObserver::containsObservedDOMTimer(DOMTimer& timer)
     164bool ContentChangeObserver::containsObservedDOMTimer(const DOMTimer& timer)
    110165{
    111     return WebThreadContainsObservedDOMTimer(&timer);
     166    return WebThreadContainsObservedDOMTimer(const_cast<DOMTimer*>(&timer));
    112167}
    113168
    114 void ContentChangeObserver::addObservedDOMTimer(DOMTimer& timer)
     169void ContentChangeObserver::addObservedDOMTimer(const DOMTimer& timer)
    115170{
    116     WebThreadAddObservedDOMTimer(&timer);
     171    WebThreadAddObservedDOMTimer(const_cast<DOMTimer*>(&timer));
    117172}
    118173
    119 void ContentChangeObserver::removeObservedDOMTimer(DOMTimer& timer)
     174void ContentChangeObserver::removeObservedDOMTimer(const DOMTimer& timer)
    120175{
    121     WebThreadRemoveObservedDOMTimer(&timer);
     176    WebThreadRemoveObservedDOMTimer(const_cast<DOMTimer*>(&timer));
    122177}
    123178
Note: See TracChangeset for help on using the changeset viewer.