| /* |
| * Copyright (C) 2013 Google 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: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following disclaimer |
| * in the documentation and/or other materials provided with the |
| * distribution. |
| * * Neither the name of Google Inc. nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "third_party/blink/renderer/core/dom/document_lifecycle.h" |
| |
| #include "base/notreached.h" |
| #include "third_party/blink/renderer/platform/runtime_enabled_features.h" |
| #include "third_party/blink/renderer/platform/wtf/assertions.h" |
| |
| #if DCHECK_IS_ON() |
| #include "third_party/blink/renderer/platform/wtf/text/wtf_string.h" |
| #endif |
| |
| namespace blink { |
| |
| static DocumentLifecycle::DeprecatedTransition* g_deprecated_transition_stack = |
| nullptr; |
| |
| DocumentLifecycle::Scope::Scope(DocumentLifecycle& lifecycle, |
| LifecycleState final_state) |
| : lifecycle_(lifecycle), final_state_(final_state) {} |
| |
| DocumentLifecycle::Scope::~Scope() { |
| lifecycle_.AdvanceTo(final_state_); |
| } |
| |
| DocumentLifecycle::DeprecatedTransition::DeprecatedTransition( |
| LifecycleState from, |
| LifecycleState to) |
| : previous_(g_deprecated_transition_stack), from_(from), to_(to) { |
| g_deprecated_transition_stack = this; |
| } |
| |
| DocumentLifecycle::DeprecatedTransition::~DeprecatedTransition() { |
| g_deprecated_transition_stack = previous_; |
| } |
| |
| DocumentLifecycle::DocumentLifecycle() |
| : state_(kUninitialized), |
| detach_count_(0), |
| disallow_transition_count_(0), |
| check_no_transition_(false) {} |
| |
| #if DCHECK_IS_ON() |
| |
| bool DocumentLifecycle::CanAdvanceTo(LifecycleState next_state) const { |
| if (StateTransitionDisallowed()) |
| return false; |
| |
| // We can stop from anywhere. |
| if (next_state == kStopping) |
| return true; |
| |
| switch (state_) { |
| case kUninitialized: |
| return next_state == kInactive; |
| case kInactive: |
| if (next_state == kStyleClean) |
| return true; |
| break; |
| case kVisualUpdatePending: |
| if (next_state == kInPreLayout) |
| return true; |
| if (next_state == kInStyleRecalc) |
| return true; |
| if (next_state == kInPerformLayout) |
| return true; |
| if (next_state == kInCompositingInputsUpdate || |
| next_state == kInCompositingAssignmentsUpdate) |
| return true; |
| break; |
| case kInStyleRecalc: |
| return next_state == kStyleClean; |
| case kStyleClean: |
| // We can synchronously recalc style. |
| if (next_state == kInStyleRecalc) |
| return true; |
| // We can notify layout objects that subtrees changed. |
| if (next_state == kInLayoutSubtreeChange) |
| return true; |
| // We can synchronously perform layout. |
| if (next_state == kInPreLayout) |
| return true; |
| if (next_state == kInPerformLayout) |
| return true; |
| // We can redundant arrive in the style clean state. |
| if (next_state == kStyleClean) |
| return true; |
| if (next_state == kLayoutClean) |
| return true; |
| if (!RuntimeEnabledFeatures::CompositeAfterPaintEnabled() && |
| next_state == kInCompositingInputsUpdate) |
| return true; |
| if (RuntimeEnabledFeatures::CompositeAfterPaintEnabled() && |
| next_state == kCompositingInputsClean) |
| return true; |
| break; |
| case kInLayoutSubtreeChange: |
| return next_state == kLayoutSubtreeChangeClean; |
| case kLayoutSubtreeChangeClean: |
| // We can synchronously recalc style. |
| if (next_state == kInStyleRecalc) |
| return true; |
| // We can synchronously perform layout. |
| if (next_state == kInPreLayout) |
| return true; |
| if (next_state == kInPerformLayout) |
| return true; |
| // Can move back to style clean. |
| if (next_state == kStyleClean) |
| return true; |
| if (next_state == kLayoutClean) |
| return true; |
| if (!RuntimeEnabledFeatures::CompositeAfterPaintEnabled() && |
| next_state == kCompositingInputsClean) |
| return true; |
| if (!RuntimeEnabledFeatures::CompositeAfterPaintEnabled() && |
| next_state == kInCompositingAssignmentsUpdate) |
| return true; |
| break; |
| case kInPreLayout: |
| if (next_state == kInStyleRecalc) |
| return true; |
| if (next_state == kStyleClean) |
| return true; |
| if (next_state == kInPreLayout) |
| return true; |
| break; |
| case kInPerformLayout: |
| return next_state == kAfterPerformLayout; |
| case kAfterPerformLayout: |
| // We can synchronously recompute layout in AfterPerformLayout. |
| // FIXME: Ideally, we would unnest this recursion into a loop. |
| if (next_state == kInPreLayout) |
| return true; |
| if (next_state == kLayoutClean) |
| return true; |
| break; |
| case kLayoutClean: |
| // We can synchronously recalc style. |
| if (next_state == kInStyleRecalc) |
| return true; |
| // We can synchronously perform layout. |
| if (next_state == kInPreLayout) |
| return true; |
| if (next_state == kInPerformLayout) |
| return true; |
| // We can redundantly arrive in the layout clean state. This situation |
| // can happen when we call layout recursively and we unwind the stack. |
| if (next_state == kLayoutClean) |
| return true; |
| if (next_state == kStyleClean) |
| return true; |
| // InAccessibility only runs if there is an ExistingAXObjectCache. |
| if (next_state == kInAccessibility) |
| return true; |
| if (!RuntimeEnabledFeatures::CompositeAfterPaintEnabled() && |
| next_state == kInCompositingInputsUpdate) |
| return true; |
| if (!RuntimeEnabledFeatures::CompositeAfterPaintEnabled() && |
| next_state == kInCompositingAssignmentsUpdate) |
| return true; |
| if (RuntimeEnabledFeatures::CompositeAfterPaintEnabled() && |
| next_state == kCompositingInputsClean) |
| return true; |
| if (next_state == kInPrePaint) |
| return true; |
| break; |
| case kInAccessibility: |
| if (next_state == kAccessibilityClean) |
| return true; |
| break; |
| case kAccessibilityClean: |
| if (!RuntimeEnabledFeatures::CompositeAfterPaintEnabled() && |
| next_state == kInCompositingInputsUpdate) |
| return true; |
| if (!RuntimeEnabledFeatures::CompositeAfterPaintEnabled() && |
| next_state == kInCompositingAssignmentsUpdate) |
| return true; |
| if (RuntimeEnabledFeatures::CompositeAfterPaintEnabled() && |
| next_state == kCompositingInputsClean) |
| return true; |
| if (RuntimeEnabledFeatures::CompositeAfterPaintEnabled() && |
| next_state == kInPrePaint) |
| return true; |
| break; |
| case kInCompositingInputsUpdate: |
| DCHECK(!RuntimeEnabledFeatures::CompositeAfterPaintEnabled()); |
| return next_state == kCompositingInputsClean; |
| case kInCompositingAssignmentsUpdate: |
| DCHECK(!RuntimeEnabledFeatures::CompositeAfterPaintEnabled()); |
| // Once we are in the compositing update, we can either just clean the |
| // inputs or do the whole of compositing. |
| return next_state == kCompositingAssignmentsClean; |
| case kCompositingInputsClean: |
| // We can return to style re-calc, layout, or the start of compositing. |
| if (next_state == kInStyleRecalc) |
| return true; |
| if (next_state == kInPreLayout) |
| return true; |
| if (next_state == kInCompositingInputsUpdate) |
| return true; |
| if (next_state == kInCompositingAssignmentsUpdate) |
| return true; |
| if (RuntimeEnabledFeatures::CompositeAfterPaintEnabled() && |
| next_state == kCompositingAssignmentsClean) |
| return true; |
| if (next_state == kInPrePaint) |
| return true; |
| if (next_state == kInAccessibility) |
| return true; |
| // Otherwise, we can continue onwards. |
| if (next_state == kCompositingAssignmentsClean) |
| return true; |
| break; |
| case kCompositingAssignmentsClean: |
| if (next_state == kInStyleRecalc) |
| return true; |
| if (next_state == kInPreLayout) |
| return true; |
| if (next_state == kInCompositingInputsUpdate) |
| return true; |
| if (next_state == kInCompositingAssignmentsUpdate) |
| return true; |
| if (next_state == kInAccessibility) |
| return true; |
| if (next_state == kInPrePaint) |
| return true; |
| if (next_state == kInPaint) |
| return true; |
| if (RuntimeEnabledFeatures::CompositeAfterPaintEnabled() && |
| next_state == kCompositingInputsClean) |
| return true; |
| break; |
| case kInPrePaint: |
| if (next_state == kPrePaintClean) |
| return true; |
| break; |
| case kPrePaintClean: |
| if (next_state == kInPaint) |
| return true; |
| if (next_state == kInStyleRecalc) |
| return true; |
| if (next_state == kInPreLayout) |
| return true; |
| if (!RuntimeEnabledFeatures::CompositeAfterPaintEnabled() && |
| next_state == kInCompositingInputsUpdate) |
| return true; |
| if (!RuntimeEnabledFeatures::CompositeAfterPaintEnabled() && |
| next_state == kInCompositingAssignmentsUpdate) |
| return true; |
| if (RuntimeEnabledFeatures::CompositeAfterPaintEnabled() && |
| next_state == kCompositingAssignmentsClean) |
| return true; |
| if (next_state == kInPrePaint) |
| return true; |
| if (next_state == kInAccessibility) |
| return true; |
| break; |
| case kInPaint: |
| if (next_state == kPaintClean) |
| return true; |
| break; |
| case kPaintClean: |
| if (next_state == kInStyleRecalc) |
| return true; |
| if (next_state == kInPreLayout) |
| return true; |
| if (!RuntimeEnabledFeatures::CompositeAfterPaintEnabled() && |
| next_state == kInCompositingInputsUpdate) |
| return true; |
| if (!RuntimeEnabledFeatures::CompositeAfterPaintEnabled() && |
| next_state == kInCompositingAssignmentsUpdate) |
| return true; |
| if (RuntimeEnabledFeatures::CompositeAfterPaintEnabled() && |
| next_state == kCompositingInputsClean) |
| return true; |
| if (next_state == kInPrePaint) |
| return true; |
| if (next_state == kInPaint) |
| return true; |
| if (next_state == kInAccessibility) |
| return true; |
| break; |
| case kStopping: |
| return next_state == kStopped; |
| case kStopped: |
| return false; |
| } |
| return false; |
| } |
| |
| bool DocumentLifecycle::CanRewindTo(LifecycleState next_state) const { |
| if (StateTransitionDisallowed()) |
| return false; |
| |
| // This transition is bogus, but we've allowed it anyway. |
| if (g_deprecated_transition_stack && |
| state_ == g_deprecated_transition_stack->From() && |
| next_state == g_deprecated_transition_stack->To()) |
| return true; |
| return state_ == kStyleClean || state_ == kLayoutSubtreeChangeClean || |
| state_ == kAfterPerformLayout || state_ == kLayoutClean || |
| state_ == kAccessibilityClean || state_ == kCompositingInputsClean || |
| state_ == kCompositingAssignmentsClean || state_ == kPrePaintClean || |
| state_ == kPaintClean; |
| } |
| |
| #define DEBUG_STRING_CASE(StateName) \ |
| case DocumentLifecycle::StateName: \ |
| return #StateName |
| |
| static WTF::String StateAsDebugString( |
| const DocumentLifecycle::LifecycleState& state) { |
| switch (state) { |
| DEBUG_STRING_CASE(kUninitialized); |
| DEBUG_STRING_CASE(kInactive); |
| DEBUG_STRING_CASE(kVisualUpdatePending); |
| DEBUG_STRING_CASE(kInStyleRecalc); |
| DEBUG_STRING_CASE(kStyleClean); |
| DEBUG_STRING_CASE(kInLayoutSubtreeChange); |
| DEBUG_STRING_CASE(kLayoutSubtreeChangeClean); |
| DEBUG_STRING_CASE(kInPreLayout); |
| DEBUG_STRING_CASE(kInPerformLayout); |
| DEBUG_STRING_CASE(kAfterPerformLayout); |
| DEBUG_STRING_CASE(kLayoutClean); |
| DEBUG_STRING_CASE(kInAccessibility); |
| DEBUG_STRING_CASE(kAccessibilityClean); |
| DEBUG_STRING_CASE(kInCompositingInputsUpdate); |
| DEBUG_STRING_CASE(kInCompositingAssignmentsUpdate); |
| DEBUG_STRING_CASE(kCompositingInputsClean); |
| DEBUG_STRING_CASE(kCompositingAssignmentsClean); |
| DEBUG_STRING_CASE(kInPrePaint); |
| DEBUG_STRING_CASE(kPrePaintClean); |
| DEBUG_STRING_CASE(kInPaint); |
| DEBUG_STRING_CASE(kPaintClean); |
| DEBUG_STRING_CASE(kStopping); |
| DEBUG_STRING_CASE(kStopped); |
| } |
| |
| NOTREACHED(); |
| return "Unknown"; |
| } |
| |
| WTF::String DocumentLifecycle::ToString() const { |
| return StateAsDebugString(state_); |
| } |
| #endif |
| |
| void DocumentLifecycle::AdvanceTo(LifecycleState next_state) { |
| #if DCHECK_IS_ON() |
| DCHECK(CanAdvanceTo(next_state)) |
| << "Cannot advance document lifecycle from " << StateAsDebugString(state_) |
| << " to " << StateAsDebugString(next_state) << "."; |
| #endif |
| CHECK(state_ == next_state || !check_no_transition_); |
| state_ = next_state; |
| } |
| |
| void DocumentLifecycle::EnsureStateAtMost(LifecycleState state) { |
| DCHECK(state == kVisualUpdatePending || state == kStyleClean || |
| state == kLayoutClean); |
| if (state_ <= state) |
| return; |
| #if DCHECK_IS_ON() |
| DCHECK(CanRewindTo(state)) |
| << "Cannot rewind document lifecycle from " << StateAsDebugString(state_) |
| << " to " << StateAsDebugString(state) << "."; |
| #endif |
| CHECK(state_ == state || !check_no_transition_); |
| state_ = state; |
| } |
| |
| } // namespace blink |
