Delete widget tree (FrameView::parent_)

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 154 matching lines @@
 // returning.
 static const unsigned kMaxUpdatePluginsIterations = 2;
 static const double kResourcePriorityUpdateDelayAfterScroll = 0.250;
 
 static bool g_initial_track_all_paint_invalidations = false;
 
 FrameView::FrameView(LocalFrame& frame, IntRect frame_rect)
     : frame_(frame),
       frame_rect_(frame_rect),
       parent_(nullptr),
+      frame_view_state_(kNotAttached),
       display_mode_(kWebDisplayModeBrowser),
       can_have_scrollbars_(true),
       has_pending_layout_(false),
       in_synchronous_post_layout_(false),
       post_layout_tasks_timer_(
           TaskRunnerHelper::Get(TaskType::kUnspecedTimer, &frame),
           this,
           &FrameView::PostLayoutTimerFired),
       update_plugins_timer_(
           TaskRunnerHelper::Get(TaskType::kUnspecedTimer, &frame),
@@ skipping 184 matching lines @@
                             if (!frame_view)
                               return;
                             frame_view->UpdateRenderThrottlingStatus(
                                 !is_visible, frame_view->subtree_throttled_);
                           },
                           WrapWeakPersistent(this)));
   visibility_observer_->Start();
 }
 
 void FrameView::Dispose() {
+  SetFrameOrPluginState(kDisposed);
   CHECK(!IsInPerformLayout());
 
   if (ScrollAnimatorBase* scroll_animator = ExistingScrollAnimator())
     scroll_animator->CancelAnimation();
   CancelProgrammaticScrollAnimation();
 
   DetachScrollbars();
 
   if (ScrollingCoordinator* scrolling_coordinator =
           this->GetScrollingCoordinator())
@@ skipping 2531 matching lines @@
   // background color of the FrameView. This should match the color drawn by
   // ViewPainter::paintBoxDecorationBackground.
   Color result = BaseBackgroundColor();
   LayoutItem document_layout_object = GetLayoutViewItem();
   if (!document_layout_object.IsNull())
     result = result.Blend(
         document_layout_object.ResolveColor(CSSPropertyBackgroundColor));
   return result;
 }
 
-FrameView* FrameView::ParentFrameView() const {
-  if (!Parent())
-    return nullptr;
-
-  Frame* parent_frame = frame_->Tree().Parent();
-  if (parent_frame && parent_frame->IsLocalFrame())
-    return ToLocalFrame(parent_frame)->View();
-
-  return nullptr;
-}
-
 void FrameView::DidChangeGlobalRootScroller() {
   if (!frame_->GetSettings() || !frame_->GetSettings()->GetViewportEnabled())
     return;
 
   // Avoid drawing two sets of scrollbars when visual viewport is enabled.
   VisualViewportScrollbarsChanged();
 }
 
 // TODO(pdr): This logic is similar to adjustScrollbarExistence and the common
 // logic should be factored into a helper.
@@ skipping 719 matching lines @@
 IntPoint FrameView::ConvertSelfToChild(const FrameOrPlugin& child,
                                        const IntPoint& point) const {
   IntPoint new_point = point;
   new_point = FrameToContents(point);
   new_point.MoveBy(-child.FrameRect().Location());
   return new_point;
 }
 
 IntRect FrameView::ConvertToContainingFrameViewBase(
     const IntRect& local_rect) const {
-  if (parent_) {
+  DCHECK(frame_view_state_ == kAttached);
+  if (FrameView* parent = ParentFrameView()) {
     // Get our layoutObject in the parent view
     LayoutPartItem layout_item = frame_->OwnerLayoutItem();
     if (layout_item.IsNull())
       return local_rect;
 
     IntRect rect(local_rect);
     // Add borders and padding??
     rect.Move((layout_item.BorderLeft() + layout_item.PaddingLeft()).ToInt(),
               (layout_item.BorderTop() + layout_item.PaddingTop()).ToInt());
-    return parent_->ConvertFromLayoutItem(layout_item, rect);
+    return parent->ConvertFromLayoutItem(layout_item, rect);
   }
 
   return local_rect;
 }
 
 IntRect FrameView::ConvertFromContainingFrameViewBase(
     const IntRect& parent_rect) const {
-  if (parent_) {
+  DCHECK(frame_view_state_ == kAttached);
+  if (FrameView* parent = ParentFrameView()) {
     IntRect local_rect = parent_rect;
     local_rect.SetLocation(
-        parent_->ConvertSelfToChild(*this, local_rect.Location()));
+        parent->ConvertSelfToChild(*this, local_rect.Location()));
     return local_rect;
   }
 
   return parent_rect;
 }
 
 IntPoint FrameView::ConvertToContainingFrameViewBase(
     const IntPoint& local_point) const {
-  if (parent_) {
+  DCHECK(frame_->IsLocalRoot() || frame_view_state_ == kAttached);
+  if (FrameView* parent = ParentFrameView()) {
     // Get our layoutObject in the parent view
     LayoutPartItem layout_item = frame_->OwnerLayoutItem();
     if (layout_item.IsNull())
       return local_point;
 
     IntPoint point(local_point);
 
     // Add borders and padding
     point.Move((layout_item.BorderLeft() + layout_item.PaddingLeft()).ToInt(),
                (layout_item.BorderTop() + layout_item.PaddingTop()).ToInt());
-    return parent_->ConvertFromLayoutItem(layout_item, point);
+    return parent->ConvertFromLayoutItem(layout_item, point);
   }
 
   return local_point;
 }
 
 IntPoint FrameView::ConvertFromContainingFrameViewBase(
     const IntPoint& parent_point) const {
-  if (parent_) {
+  DCHECK(frame_->IsLocalRoot() || frame_view_state_ == kAttached);
+  if (FrameView* parent = ParentFrameView()) {
     // Get our layoutObject in the parent view
     LayoutPartItem layout_item = frame_->OwnerLayoutItem();
     if (layout_item.IsNull())
       return parent_point;
 
-    IntPoint point = parent_->ConvertToLayoutItem(layout_item, parent_point);
+    IntPoint point = parent->ConvertToLayoutItem(layout_item, parent_point);
     // Subtract borders and padding
     point.Move((-layout_item.BorderLeft() - layout_item.PaddingLeft()).ToInt(),
                (-layout_item.BorderTop() - layout_item.PaddingTop()).ToInt());
     return point;
   }
 
   return parent_point;
 }
 
 void FrameView::SetInitialTracksPaintInvalidationsForTesting(
@@ skipping 115 matching lines @@
   animating_scrollable_areas_->insert(scrollable_area);
 }
 
 void FrameView::RemoveAnimatingScrollableArea(ScrollableArea* scrollable_area) {
   if (!animating_scrollable_areas_)
     return;
   animating_scrollable_areas_->erase(scrollable_area);
 }
 
 void FrameView::SetParent(FrameView* parent) {
+  if (parent) {
+    SetFrameOrPluginState(kAttached);
+  }
+  if (!parent) {
+    DCHECK(frame_view_state_ == kAttached ||
+           (frame_view_state_ == kDisposed && parent_));
+    SetFrameOrPluginState(kNotAttached);
+  }
+
   if (parent == parent_)
     return;
 
   DCHECK(!parent || !parent_);
   if (!parent || !parent->IsVisible())
     SetParentVisible(false);
   parent_ = parent;
   if (parent && parent->IsVisible())
     SetParentVisible(true);
 
+  DCHECK(parent == ParentFrameView());
+
   UpdateParentScrollableAreaSet();
   SetupRenderThrottling();
 
   if (ParentFrameView())
     subtree_throttled_ = ParentFrameView()->CanThrottleRendering();
 }
 
+FrameView* FrameView::Parent() const {
+  if (frame_view_state_ == kNotAttached || frame_view_state_ == kAttached)
+    DCHECK(ParentFrameView() == parent_);
+
+  return parent_;
+}
+
+FrameView* FrameView::ParentFrameView() const {
+  if (frame_view_state_ != kAttached)
+    return nullptr;
+
+  Frame* parent_frame = frame_->Tree().Parent();
+  if (parent_frame && parent_frame->IsLocalFrame())
+    return ToLocalFrame(parent_frame)->View();
+
+  return nullptr;
+}
+
+void FrameView::SetFrameOrPluginState(FrameOrPluginState state) {
+  VLOG(1) << "SetFrameOrPluginState " << this << " " << frame_view_state_
+          << "->" << state;
+  if (VLOG_IS_ON(2))
+    base::debug::StackTrace(10).Print();
+  switch (state) {
+    case kNotAttached:
+      DCHECK(frame_view_state_ == kAttached || frame_view_state_ == kDisposed);
+      break;
+    case kAttached:
+      DCHECK(frame_view_state_ == kNotAttached ||
+             frame_view_state_ == kDisposed);
+      break;
+    case kDeferred:
+      DCHECK(frame_view_state_ == kNotAttached ||
+             frame_view_state_ == kAttached || frame_view_state_ == kDeferred ||
+             frame_view_state_ == kDisposed);
+      break;
+    case kDisposed:
+      DCHECK(frame_view_state_ == kNotAttached ||
+             frame_view_state_ == kAttached || frame_view_state_ == kDeferred ||
+             frame_view_state_ == kDisposed);
+      break;
+    default:
+      NOTREACHED();
+  }
+  frame_view_state_ = state;
+}
+
 void FrameView::RemoveChild(FrameOrPlugin* child) {
   DCHECK(child->Parent() == this);
 
   if (child->IsFrameView()) {
     if (!RuntimeEnabledFeatures::rootLayerScrollingEnabled())
       RemoveScrollableArea(ToFrameView(child));
   } else if (child->IsPluginView()) {
     PluginView* plugin = ToPluginView(child);
     DCHECK(plugins_.Contains(plugin));
     plugins_.erase(plugin);
@@ skipping 845 matching lines @@
          frame_point.Y() > vertical_scrollbar_y_min;
 }
 
 bool FrameView::ScrollbarCornerPresent() const {
   return (HorizontalScrollbar() &&
           Width() - HorizontalScrollbar()->Width() > 0) ||
          (VerticalScrollbar() && Height() - VerticalScrollbar()->Height() > 0);
 }
 
 IntRect FrameView::ConvertToRootFrame(const IntRect& local_rect) const {
-  if (parent_) {
+  // TODO(joelhockey): I expect that this should only be called in state
+  // kAttached However, this is called in state
+  // kNotAttached: browser_tests
+  // --gtest_filter=DevToolsExtensionTest.HttpIframeInDevToolsExtensionDevtools
+  // kDeferred: interactive_ui_tests
+  // --gtest_filter=SitePerProcessInteractiveBrowserTest.FullscreenElementInMultipleSubframes
+  // kDisposed: run-webkit-tests -t Default
+  // third_party/WebKit/LayoutTests/virtual/disable-spinvalidation/compositing/iframes/invisible-nested-iframe-hide.html
+  DCHECK(frame_->IsLocalRoot() || frame_view_state_ == kNotAttached ||
+         frame_view_state_ == kAttached || frame_view_state_ == kDeferred ||
+         frame_view_state_ == kDisposed);
+  if (FrameView* parent = ParentFrameView()) {
     IntRect parent_rect = ConvertToContainingFrameViewBase(local_rect);
-    return parent_->ConvertToRootFrame(parent_rect);
+    return parent->ConvertToRootFrame(parent_rect);
   }
   return local_rect;
 }
 
 IntPoint FrameView::ConvertToRootFrame(const IntPoint& local_point) const {
-  if (parent_) {
+  DCHECK(frame_->IsLocalRoot() || frame_view_state_ == kAttached);
+  if (FrameView* parent = ParentFrameView()) {
     IntPoint parent_point = ConvertToContainingFrameViewBase(local_point);
-    return parent_->ConvertToRootFrame(parent_point);
+    return parent->ConvertToRootFrame(parent_point);
   }
   return local_point;
 }
 
 IntRect FrameView::ConvertFromRootFrame(
     const IntRect& rect_in_root_frame) const {
-  if (parent_) {
-    IntRect parent_rect = parent_->ConvertFromRootFrame(rect_in_root_frame);
+  // TODO(joelhockey): I expect that this should only be called in state
+  // kAttached However, this is called in state kDeferred in
+  // interactive_ui_tests
+  // --gtest_filter=SitePerProcessInteractiveBrowserTest.FullscreenElementInMultipleSubframes
+  DCHECK(frame_->IsLocalRoot() || frame_view_state_ == kAttached ||
+         frame_view_state_ == kDeferred);
+  if (FrameView* parent = ParentFrameView()) {
+    IntRect parent_rect = parent->ConvertFromRootFrame(rect_in_root_frame);
     return ConvertFromContainingFrameViewBase(parent_rect);
   }
   return rect_in_root_frame;
 }
 
 IntPoint FrameView::ConvertFromRootFrame(
     const IntPoint& point_in_root_frame) const {
-  if (parent_) {
-    IntPoint parent_point = parent_->ConvertFromRootFrame(point_in_root_frame);
+  // TODO(joelhockey): Usually parent should only be called when in state
+  // kAtached, but this is also called in state:
+  // kDisposed: content_shell --run-layout-test
+  // fast/events/frame-detached-in-mousedown.html kDeferred: content_shell
+  // --run-layout-test
+  // external/wpt/fullscreen/api/document-exit-fullscreen-nested-in-iframe-manual.html
+  DCHECK(frame_->IsLocalRoot() || frame_view_state_ == kAttached ||
+         frame_view_state_ == kDeferred || frame_view_state_ == kDisposed);
+  if (FrameView* parent = ParentFrameView()) {
+    IntPoint parent_point = parent->ConvertFromRootFrame(point_in_root_frame);
     return ConvertFromContainingFrameViewBase(parent_point);
   }
   return point_in_root_frame;
 }
 
 FloatPoint FrameView::ConvertFromRootFrame(
     const FloatPoint& point_in_root_frame) const {
   // FrameViews / windows are required to be IntPoint aligned, but we may
   // need to convert FloatPoint values within them (eg. for event
   // co-ordinates).
@@ skipping 29 matching lines @@
           !layout_view_item.IsNull() ? layout_view_item.Compositor() : nullptr)
     compositor->SetNeedsCompositingUpdate(update_type);
 }
 
 void FrameView::SetParentVisible(bool visible) {
   if (IsParentVisible() == visible)
     return;
 
   // As parent visibility changes, we may need to recomposite this frame view
   // and potentially child frame views.
-  SetNeedsCompositingUpdate(GetLayoutViewItem(), kCompositingUpdateRebuildTree);
+  // TODO(joelhockey): This call doesn't seem to be needed, and it
+  // causes errors during dispose when checking document lifecycle state.
+  // SetNeedsCompositingUpdate(GetLayoutViewItem(),
+  // kCompositingUpdateRebuildTree);
 
   parent_visible_ = visible;
 
   if (!IsSelfVisible())
     return;
 
   ForAllChildViewsAndPlugins([visible](FrameOrPlugin& frame_or_plugin) {
     frame_or_plugin.SetParentVisible(visible);
   });
 }
@@ skipping 584 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