Replace ASSERT with DCHECK in core/

third_party/WebKit/Source/core/frame/FrameView.cpp

 /*
  * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
  *                     1999 Lars Knoll <knoll@kde.org>
  *                     1999 Antti Koivisto <koivisto@kde.org>
  *                     2000 Dirk Mueller <mueller@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *           (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
@@ skipping 214 matching lines @@
 
 FrameView* FrameView::Create(LocalFrame& frame, const IntSize& initial_size) {
   FrameView* view = new FrameView(frame, IntRect(IntPoint(), initial_size));
   view->SetLayoutSizeInternal(initial_size);
 
   view->Show();
   return view;
 }
 
 FrameView::~FrameView() {
-  ASSERT(has_been_disposed_);
+#if DCHECK_IS_ON()
+  DCHECK(has_been_disposed_);
+#endif
 }
 
 DEFINE_TRACE(FrameView) {
   visitor->Trace(frame_);
   visitor->Trace(parent_);
   visitor->Trace(fragment_anchor_);
   visitor->Trace(scrollable_areas_);
   visitor->Trace(animating_scrollable_areas_);
   visitor->Trace(auto_size_info_);
   visitor->Trace(children_);
@@ skipping 737 matching lines @@
   // for the first time, or when the LayoutSVGRoot size has changed dynamically
   // (eg. via <script>).
   FrameView* frame_view = owner_layout_item.GetFrame()->View();
 
   // Mark the owner layoutObject as needing layout.
   owner_layout_item.SetNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(
       LayoutInvalidationReason::kUnknown);
 
   // Synchronously enter layout, to layout the view containing the host
   // object/embed/iframe.
-  ASSERT(frame_view);
+  DCHECK(frame_view);
   frame_view->UpdateLayout();
 }
 
 void FrameView::PerformPreLayoutTasks() {
   TRACE_EVENT0("blink,benchmark", "FrameView::performPreLayoutTasks");
   Lifecycle().AdvanceTo(DocumentLifecycle::kInPreLayout);
 
   // Don't schedule more layouts, we're in one.
   AutoReset<bool> change_scheduling_enabled(&layout_scheduling_enabled_, false);
 
@@ skipping 97 matching lines @@
   if (in_subtree_layout && HasOrthogonalWritingModeRoots()) {
     // If we're going to lay out from each subtree root, rather than once from
     // LayoutView, we need to merge the depth-ordered orthogonal writing mode
     // root list into the depth-ordered list of subtrees scheduled for
     // layout. Otherwise, during layout of one such subtree, we'd risk skipping
     // over a subtree of objects needing layout.
     DCHECK(!layout_subtree_root_list_.IsEmpty());
     ScheduleOrthogonalWritingModeRootsForLayout();
   }
 
-  ASSERT(!IsInPerformLayout());
+  DCHECK(!IsInPerformLayout());
   Lifecycle().AdvanceTo(DocumentLifecycle::kInPerformLayout);
 
   // performLayout is the actual guts of layout().
   // FIXME: The 300 other lines in layout() probably belong in other helper
   // functions so that a single human could understand what layout() is actually
   // doing.
 
   ForceLayoutParentViewIfNeeded();
 
   if (in_subtree_layout) {
@@ skipping 50 matching lines @@
     // we can get stuck in a nasty cycle unless we call it through the timer
     // here.
     post_layout_tasks_timer_.StartOneShot(0, BLINK_FROM_HERE);
     if (NeedsLayout())
       UpdateLayout();
   }
 }
 
 void FrameView::UpdateLayout() {
   // We should never layout a Document which is not in a LocalFrame.
-  ASSERT(frame_);
+  DCHECK(frame_);
   ASSERT(frame_->View() == this);
-  ASSERT(frame_->GetPage());
+  DCHECK(frame_->GetPage());
 
   ScriptForbiddenScope forbid_script;
 
   if (IsInPerformLayout() || ShouldThrottleRendering() ||
       !frame_->GetDocument()->IsActive())
     return;
 
   TRACE_EVENT0("blink,benchmark", "FrameView::layout");
 
   if (auto_size_info_)
@@ skipping 111 matching lines @@
 
     TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
         TRACE_DISABLED_BY_DEFAULT("blink.debug.layout.trees"), "LayoutTree",
         this, TracedLayoutObject::Create(*GetLayoutView(), false));
 
     PerformLayout(in_subtree_layout);
 
     if (!in_subtree_layout && !document->Printing())
       AdjustViewSizeAndLayout();
 
-    ASSERT(layout_subtree_root_list_.IsEmpty());
+    DCHECK(layout_subtree_root_list_.IsEmpty());
   }  // Reset m_layoutSchedulingEnabled to its previous value.
   CheckDoesNotNeedLayout();
 
   frame_timing_requests_dirty_ = true;
 
   // FIXME: Could find the common ancestor layer of all dirty subtrees and mark
   // from there. crbug.com/462719
   GetLayoutViewItem().EnclosingLayer()->UpdateLayerPositionsAfterLayout();
 
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
@@ skipping 39 matching lines @@
     const PaintInvalidationState& paint_invalidation_state) {
   DCHECK(!RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled());
 
   if (ShouldThrottleRendering())
     return;
 
   Lifecycle().AdvanceTo(DocumentLifecycle::kInPaintInvalidation);
 
   RELEASE_ASSERT(!GetLayoutViewItem().IsNull());
   LayoutViewItem root_for_paint_invalidation = GetLayoutViewItem();
-  ASSERT(!root_for_paint_invalidation.NeedsLayout());
+  DCHECK(!root_for_paint_invalidation.NeedsLayout());
 
   TRACE_EVENT1("blink", "FrameView::invalidateTree", "root",
                root_for_paint_invalidation.DebugName().Ascii());
 
   InvalidatePaint(paint_invalidation_state);
   root_for_paint_invalidation.DeprecatedInvalidateTree(
       paint_invalidation_state);
 
 #if DCHECK_IS_ON()
   GetLayoutView()->AssertSubtreeClearedPaintInvalidationFlags();
@@ skipping 130 matching lines @@
         if (!did_need_layout && !frame_view->ShouldThrottleRendering())
           frame_view->CheckDoesNotNeedLayout();
       } else {
         part->UpdateGeometry();
       }
     }
   }
 }
 
 void FrameView::AddPartToUpdate(LayoutEmbeddedObject& object) {
-  ASSERT(IsInPerformLayout());
+  DCHECK(IsInPerformLayout());
   // Tell the DOM element that it needs a FrameViewBase update.
   Node* node = object.GetNode();
-  ASSERT(node);
+  DCHECK(node);
   if (isHTMLObjectElement(*node) || isHTMLEmbedElement(*node))
     ToHTMLPlugInElement(node)->SetNeedsPluginUpdate(true);
 
   part_update_set_.insert(&object);
 }
 
 void FrameView::SetDisplayMode(WebDisplayMode mode) {
   if (mode == display_mode_)
     return;
 
@@ skipping 43 matching lines @@
                                StyleChangeReason::kStyleSheetChange));
 }
 
 bool FrameView::ContentsInCompositedLayer() const {
   LayoutViewItem layout_view_item = this->GetLayoutViewItem();
   return !layout_view_item.IsNull() &&
          layout_view_item.GetCompositingState() == kPaintsIntoOwnBacking;
 }
 
 void FrameView::AddBackgroundAttachmentFixedObject(LayoutObject* object) {
-  ASSERT(!background_attachment_fixed_objects_.Contains(object));
+  DCHECK(!background_attachment_fixed_objects_.Contains(object));
 
   background_attachment_fixed_objects_.insert(object);
   if (ScrollingCoordinator* scrolling_coordinator =
           this->GetScrollingCoordinator())
     scrolling_coordinator
         ->FrameViewHasBackgroundAttachmentFixedObjectsDidChange(this);
 
   // Ensure main thread scrolling reasons are recomputed.
   if (RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled()) {
     SetNeedsPaintPropertyUpdate();
     // The object's scroll properties are not affected by its own background.
     object->SetAncestorsNeedPaintPropertyUpdateForMainThreadScrolling();
   }
 }
 
 void FrameView::RemoveBackgroundAttachmentFixedObject(LayoutObject* object) {
-  ASSERT(background_attachment_fixed_objects_.Contains(object));
+  DCHECK(background_attachment_fixed_objects_.Contains(object));
 
   background_attachment_fixed_objects_.erase(object);
   if (ScrollingCoordinator* scrolling_coordinator =
           this->GetScrollingCoordinator())
     scrolling_coordinator
         ->FrameViewHasBackgroundAttachmentFixedObjectsDidChange(this);
 
   // Ensure main thread scrolling reasons are recomputed.
   if (RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled()) {
     SetNeedsPaintPropertyUpdate();
@@ skipping 154 matching lines @@
   }
   return false;
 }
 
 bool FrameView::InvalidateViewportConstrainedObjects() {
   bool fast_path_allowed = true;
   for (const auto& viewport_constrained_object :
        *viewport_constrained_objects_) {
     LayoutObject* layout_object = viewport_constrained_object;
     LayoutItem layout_item = LayoutItem(layout_object);
-    ASSERT(layout_item.Style()->HasViewportConstrainedPosition());
-    ASSERT(layout_item.HasLayer());
+    DCHECK(layout_item.Style()->HasViewportConstrainedPosition());
+    DCHECK(layout_item.HasLayer());
     PaintLayer* layer = LayoutBoxModel(layout_item).Layer();
 
     if (layer->IsPaintInvalidationContainer())
       continue;
 
     if (layer->SubtreeIsInvisible())
       continue;
 
     // invalidate even if there is an ancestor with a filter that moves pixels.
     layout_item
@@ skipping 32 matching lines @@
   return true;
 }
 
 void FrameView::ScrollContentsSlowPath() {
   TRACE_EVENT0("blink", "FrameView::scrollContentsSlowPath");
   // We need full invalidation during slow scrolling. For slimming paint, full
   // invalidation of the LayoutView is not enough. We also need to invalidate
   // all of the objects.
   // FIXME: Find out what are enough to invalidate in slow path scrolling.
   // crbug.com/451090#9.
-  ASSERT(!GetLayoutViewItem().IsNull());
+  DCHECK(!GetLayoutViewItem().IsNull());
   if (ContentsInCompositedLayer())
     GetLayoutViewItem()
         .Layer()
         ->GetCompositedLayerMapping()
         ->SetContentsNeedDisplay();
   else
     GetLayoutViewItem()
         .SetShouldDoFullPaintInvalidationIncludingNonCompositingDescendants();
 
   if (ContentsInCompositedLayer()) {
     IntRect update_rect = VisibleContentRect();
-    ASSERT(!GetLayoutViewItem().IsNull());
+    DCHECK(!GetLayoutViewItem().IsNull());
     // FIXME: We should not allow paint invalidation out of paint invalidation
     // state. crbug.com/457415
     DisablePaintInvalidationStateAsserts disabler;
     GetLayoutViewItem().InvalidatePaintRectangle(LayoutRect(update_rect));
   }
   LayoutPartItem frame_layout_item = frame_->OwnerLayoutItem();
   if (!frame_layout_item.IsNull()) {
     if (IsEnclosedInCompositingLayer()) {
       LayoutRect rect(
           frame_layout_item.BorderLeft() + frame_layout_item.PaddingLeft(),
@@ skipping 31 matching lines @@
   // Try again after decoding the ref, based on the document's encoding.
   if (frame_->GetDocument()->Encoding().IsValid())
     ProcessUrlFragmentHelper(
         DecodeURLEscapeSequences(fragment_identifier,
                                  frame_->GetDocument()->Encoding()),
         behavior);
 }
 
 bool FrameView::ProcessUrlFragmentHelper(const String& name,
                                          UrlFragmentBehavior behavior) {
-  ASSERT(frame_->GetDocument());
+  DCHECK(frame_->GetDocument());
 
   if (behavior == kUrlFragmentScroll &&
       !frame_->GetDocument()->IsRenderingReady()) {
     frame_->GetDocument()->SetGotoAnchorNeededAfterStylesheetsLoad(true);
     return false;
   }
 
   frame_->GetDocument()->SetGotoAnchorNeededAfterStylesheetsLoad(false);
 
   Element* anchor_node = frame_->GetDocument()->FindAnchor(name);
@@ skipping 32 matching lines @@
       if (behavior == kUrlFragmentScroll)
         frame_->GetDocument()->SetSequentialFocusNavigationStartingPoint(
             anchor_node);
       frame_->GetDocument()->ClearFocusedElement();
     }
   }
   return true;
 }
 
 void FrameView::SetFragmentAnchor(Node* anchor_node) {
-  ASSERT(anchor_node);
+  DCHECK(anchor_node);
   fragment_anchor_ = anchor_node;
 
   // We need to update the layout tree before scrolling.
   frame_->GetDocument()->UpdateStyleAndLayoutTree();
 
   // If layout is needed, we will scroll in performPostLayoutTasks. Otherwise,
   // scroll immediately.
   LayoutViewItem layout_view_item = this->GetLayoutViewItem();
   if (!layout_view_item.IsNull() && layout_view_item.NeedsLayout())
     UpdateLayout();
@@ skipping 33 matching lines @@
 }
 
 IntSize FrameView::GetLayoutSize(
     IncludeScrollbarsInRect scrollbar_inclusion) const {
   return scrollbar_inclusion == kExcludeScrollbars
              ? ExcludeScrollbars(layout_size_)
              : layout_size_;
 }
 
 void FrameView::SetLayoutSize(const IntSize& size) {
-  ASSERT(!LayoutSizeFixedToFrameSize());
+  DCHECK(!LayoutSizeFixedToFrameSize());
 
   SetLayoutSizeInternal(size);
 }
 
 void FrameView::DidScrollTimerFired(TimerBase*) {
   if (frame_->GetDocument() &&
       !frame_->GetDocument()->GetLayoutViewItem().IsNull())
     frame_->GetDocument()->Fetcher()->UpdateAllImageResourcePriorities();
 }
 
@@ skipping 81 matching lines @@
   return true;
 }
 
 void FrameView::UpdateCompositedSelectionIfNeeded() {
   if (!RuntimeEnabledFeatures::compositedSelectionUpdateEnabled())
     return;
 
   TRACE_EVENT0("blink", "FrameView::updateCompositedSelectionIfNeeded");
 
   Page* page = GetFrame().GetPage();
-  ASSERT(page);
+  DCHECK(page);
 
   CompositedSelection selection;
   LocalFrame* focused_frame = page->GetFocusController().FocusedFrame();
   LocalFrame* local_frame =
       (focused_frame &&
        (focused_frame->LocalFrameRoot() == frame_->LocalFrameRoot()))
           ? focused_frame
           : nullptr;
 
   if (local_frame && ComputeCompositedSelection(*local_frame, selection)) {
@@ skipping 392 matching lines @@
 
     // Prevent plugins from causing infinite updates of themselves.
     // FIXME: Do we really need to prevent this?
     part_update_set_.erase(&object);
   }
 
   return part_update_set_.IsEmpty();
 }
 
 void FrameView::UpdatePluginsTimerFired(TimerBase*) {
-  ASSERT(!IsInPerformLayout());
+  DCHECK(!IsInPerformLayout());
   for (unsigned i = 0; i < kMaxUpdatePluginsIterations; ++i) {
     if (UpdatePlugins())
       return;
   }
 }
 
 void FrameView::FlushAnyPendingPostLayoutTasks() {
-  ASSERT(!IsInPerformLayout());
+  DCHECK(!IsInPerformLayout());
   if (post_layout_tasks_timer_.IsActive())
     PerformPostLayoutTasks();
   if (update_plugins_timer_.IsActive()) {
     update_plugins_timer_.Stop();
     UpdatePluginsTimerFired(nullptr);
   }
 }
 
 void FrameView::ScheduleUpdatePluginsIfNecessary() {
-  ASSERT(!IsInPerformLayout());
+  DCHECK(!IsInPerformLayout());
   if (update_plugins_timer_.IsActive() || part_update_set_.IsEmpty())
     return;
   update_plugins_timer_.StartOneShot(0, BLINK_FROM_HERE);
 }
 
 void FrameView::PerformPostLayoutTasks() {
   // FIXME: We can reach here, even when the page is not active!
   // http/tests/inspector/elements/html-link-import.html and many other
   // tests hit that case.
-  // We should ASSERT(isActive()); or at least return early if we can!
+  // We should DCHECK(isActive()); or at least return early if we can!
 
   // Always called before or after performLayout(), part of the highest-level
   // layout() call.
-  ASSERT(!IsInPerformLayout());
+  DCHECK(!IsInPerformLayout());
   TRACE_EVENT0("blink,benchmark", "FrameView::performPostLayoutTasks");
 
   post_layout_tasks_timer_.Stop();
 
   frame_->Selection().DidLayout();
 
-  ASSERT(frame_->GetDocument());
+  DCHECK(frame_->GetDocument());
 
   FontFaceSet::DidLayout(*frame_->GetDocument());
   // Cursor update scheduling is done by the local root, which is the main frame
   // if there are no RemoteFrame ancestors in the frame tree. Use of
   // localFrameRoot() is discouraged but will change when cursor update
   // scheduling is moved from EventHandler to PageEventHandler.
   GetFrame().LocalFrameRoot().GetEventHandler().ScheduleCursorUpdate();
 
   UpdateGeometries();
 
   // Plugins could have torn down the page inside updateGeometries().
   if (GetLayoutViewItem().IsNull())
     return;
 
   ScheduleUpdatePluginsIfNecessary();
 
   if (ScrollingCoordinator* scrolling_coordinator =
           this->GetScrollingCoordinator())
     scrolling_coordinator->NotifyGeometryChanged();
 
   ScrollToFragmentAnchor();
   SendResizeEventIfNeeded();
 }
 
 bool FrameView::WasViewportResized() {
-  ASSERT(frame_);
+  DCHECK(frame_);
   LayoutViewItem layout_view_item = this->GetLayoutViewItem();
   if (layout_view_item.IsNull())
     return false;
-  ASSERT(layout_view_item.Style());
+  DCHECK(layout_view_item.Style());
   return (GetLayoutSize(kIncludeScrollbars) != last_viewport_size_ ||
           layout_view_item.Style()->Zoom() != last_zoom_factor_);
 }
 
 void FrameView::SendResizeEventIfNeeded() {
-  ASSERT(frame_);
+  DCHECK(frame_);
 
   LayoutViewItem layout_view_item = this->GetLayoutViewItem();
   if (layout_view_item.IsNull() || layout_view_item.GetDocument().Printing())
     return;
 
   if (!WasViewportResized())
     return;
 
   last_viewport_size_ = GetLayoutSize(kIncludeScrollbars);
   last_zoom_factor_ = layout_view_item.Style()->Zoom();
@@ skipping 639 matching lines @@
 }
 
 void FrameView::PaintTree() {
   TRACE_EVENT0("blink", "FrameView::paintTree");
   SCOPED_BLINK_UMA_HISTOGRAM_TIMER("Blink.Paint.UpdateTime");
 
   ASSERT(GetFrame() == GetPage()->MainFrame() ||
          (!GetFrame().Tree().Parent()->IsLocalFrame()));
 
   LayoutViewItem view = GetLayoutViewItem();
-  ASSERT(!view.IsNull());
+  DCHECK(!view.IsNull());
   ForAllNonThrottledFrameViews([](FrameView& frame_view) {
     frame_view.Lifecycle().AdvanceTo(DocumentLifecycle::kInPaint);
   });
 
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     if (GetLayoutView()->Layer()->NeedsRepaint()) {
       GraphicsContext graphics_context(*paint_controller_);
       if (RuntimeEnabledFeatures::printBrowserEnabled())
         graphics_context.SetPrinting(true);
       Paint(graphics_context, CullRect(LayoutRect::InfiniteIntRect()));
@@ skipping 531 matching lines @@
 void FrameView::RemoveResizerArea(LayoutBox& resizer_box) {
   if (!resizer_areas_)
     return;
 
   ResizerAreaSet::iterator it = resizer_areas_->find(&resizer_box);
   if (it != resizer_areas_->end())
     resizer_areas_->erase(it);
 }
 
 void FrameView::AddScrollableArea(ScrollableArea* scrollable_area) {
-  ASSERT(scrollable_area);
+  DCHECK(scrollable_area);
   if (!scrollable_areas_)
     scrollable_areas_ = new ScrollableAreaSet;
   scrollable_areas_->insert(scrollable_area);
 
   if (ScrollingCoordinator* scrolling_coordinator =
           this->GetScrollingCoordinator())
     scrolling_coordinator->ScrollableAreasDidChange();
 }
 
 void FrameView::RemoveScrollableArea(ScrollableArea* scrollable_area) {
   if (!scrollable_areas_)
     return;
   scrollable_areas_->erase(scrollable_area);
 
   if (ScrollingCoordinator* scrolling_coordinator =
           this->GetScrollingCoordinator())
     scrolling_coordinator->ScrollableAreasDidChange();
 }
 
 void FrameView::AddAnimatingScrollableArea(ScrollableArea* scrollable_area) {
-  ASSERT(scrollable_area);
+  DCHECK(scrollable_area);
   if (!animating_scrollable_areas_)
     animating_scrollable_areas_ = new ScrollableAreaSet;
   animating_scrollable_areas_->insert(scrollable_area);
 }
 
 void FrameView::RemoveAnimatingScrollableArea(ScrollableArea* scrollable_area) {
   if (!animating_scrollable_areas_)
     return;
   animating_scrollable_areas_->erase(scrollable_area);
 }
@@ skipping 430 matching lines @@
     if (old_rect != VerticalScrollbar()->FrameRect())
       SetScrollbarNeedsPaintInvalidation(kVerticalScrollbar);
 
     VerticalScrollbar()->SetProportion(VisibleHeight(), ContentsHeight());
     VerticalScrollbar()->OffsetDidChange();
   }
 }
 
 bool FrameView::AdjustScrollbarExistence(
     ComputeScrollbarExistenceOption option) {
-  ASSERT(in_update_scrollbars_);
+  DCHECK(in_update_scrollbars_);
 
   // If we came in here with the view already needing a layout, then go ahead
   // and do that first.  (This will be the common case, e.g., when the page
   // changes due to window resizing for example).  This layout will not re-enter
   // updateScrollbars and does not count towards our max layout pass total.
   if (!scrollbars_suppressed_)
     ScrollbarExistenceDidChange();
 
   bool has_horizontal_scrollbar = HorizontalScrollbar();
   bool has_vertical_scrollbar = VerticalScrollbar();
@@ skipping 1090 matching lines @@
 void FrameView::SetAnimationHost(
     std::unique_ptr<CompositorAnimationHost> host) {
   animation_host_ = std::move(host);
 }
 
 LayoutUnit FrameView::CaretWidth() const {
   return LayoutUnit(GetChromeClient()->WindowToViewportScalar(1));
 }
 
 }  // namespace blink