Remove FrameViewBase as base class of RemoteFrameView.

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 227 matching lines @@
 }
 
 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_);
-  visitor->Trace(plugins_);
   visitor->Trace(scrollbars_);
   visitor->Trace(viewport_scrollable_area_);
   visitor->Trace(visibility_observer_);
   visitor->Trace(scroll_anchor_);
   visitor->Trace(anchoring_adjustment_queue_);
   visitor->Trace(scrollbar_manager_);
   visitor->Trace(print_context_);
-  FrameViewBase::Trace(visitor);
   ScrollableArea::Trace(visitor);
 }
 
 void FrameView::Reset() {
   // The compositor throttles the main frame using deferred commits, we can't
   // throttle it here or it seems the root compositor doesn't get setup
   // properly.
   if (RuntimeEnabledFeatures::
           renderingPipelineThrottlingLoadingIframesEnabled())
     lifecycle_updates_throttled_ = !GetFrame().IsMainFrame();
@@ skipping 108 matching lines @@
   // Destroy |m_autoSizeInfo| as early as possible, to avoid dereferencing
   // partially destroyed |this| via |m_autoSizeInfo->m_frameView|.
   auto_size_info_.Clear();
 
   post_layout_tasks_timer_.Stop();
   did_scroll_timer_.Stop();
 
   // FIXME: Do we need to do something here for OOPI?
   HTMLFrameOwnerElement* owner_element = frame_->DeprecatedLocalOwner();
   // TODO(dcheng): It seems buggy that we can have an owner element that points
-  // to another FrameViewBase. This can happen when a plugin element loads a
-  // frame (FrameViewBase A of type FrameView) and then loads a plugin
-  // (FrameViewBase B of type WebPluginContainerImpl). In this case, the frame's
-  // view is A and the frame element's owned FrameViewBase is B. See
+  // to another FrameOrPlugin. This can happen when a plugin element loads a
+  // frame (FrameOrPlugin A of type FrameView) and then loads a plugin
+  // (FrameOrPlugin B of type WebPluginContainerImpl). In this case, the frame's
+  // view is A and the frame element's OwnedWidget is B. See
   // https://crbug.com/673170 for an example.
   if (owner_element && owner_element->OwnedWidget() == this)
     owner_element->SetWidget(nullptr);
 
   ClearPrintContext();
 
 #if DCHECK_IS_ON()
   has_been_disposed_ = true;
 #endif
 }
@@ skipping 100 matching lines @@
     UpdateScrollbarGeometry();
     UpdateScrollCorner();
     PositionScrollbarLayers();
   }
 }
 
 void FrameView::InvalidateAllCustomScrollbarsOnActiveChanged() {
   bool uses_window_inactive_selector =
       frame_->GetDocument()->GetStyleEngine().UsesWindowInactiveSelector();
 
-  const ChildrenSet* view_children = Children();
-  for (const Member<FrameViewBase>& child : *view_children) {
-    FrameViewBase* frame_view_base = child.Get();
-    if (frame_view_base->IsFrameView()) {
-      ToFrameView(frame_view_base)
-          ->InvalidateAllCustomScrollbarsOnActiveChanged();
-    }
+  for (const auto& child : children_) {
+    if (child->IsFrameView())
+      ToFrameView(child)->InvalidateAllCustomScrollbarsOnActiveChanged();
   }
 
-  for (const Member<Scrollbar>& scrollbar : *Scrollbars()) {
+  for (const auto& scrollbar : scrollbars_) {
     if (uses_window_inactive_selector && scrollbar->IsCustomScrollbar())
       scrollbar->StyleChanged();
   }
 
   if (uses_window_inactive_selector)
     RecalculateCustomScrollbarStyle();
 }
 
 void FrameView::Clear() {
   Reset();
@@ skipping 633 matching lines @@
   if (!in_synchronous_post_layout_) {
     in_synchronous_post_layout_ = true;
     // Calls resumeScheduledEvents()
     PerformPostLayoutTasks();
     in_synchronous_post_layout_ = false;
   }
 
   if (!post_layout_tasks_timer_.IsActive() &&
       (NeedsLayout() || in_synchronous_post_layout_)) {
     // If we need layout or are already in a synchronous call to
-    // postLayoutTasks(), defer FrameViewBase updates and event dispatch until
+    // postLayoutTasks(), defer FrameView updates and event dispatch until
     // after we return.  postLayoutTasks() can make us need to update again, and
     // 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.
   DCHECK(frame_);
-  ASSERT(frame_->View() == this);
+  DCHECK(frame_->View() == this);
   DCHECK(frame_->GetPage());
 
   ScriptForbiddenScope forbid_script;
 
   if (IsInPerformLayout() || ShouldThrottleRendering() ||
       !frame_->GetDocument()->IsActive())
     return;
 
   TRACE_EVENT0("blink,benchmark", "FrameView::layout");
 
@@ skipping 324 matching lines @@
           frame_view->CheckDoesNotNeedLayout();
       } else {
         part->UpdateGeometry();
       }
     }
   }
 }
 
 void FrameView::AddPartToUpdate(LayoutEmbeddedObject& object) {
   DCHECK(IsInPerformLayout());
-  // Tell the DOM element that it needs a FrameViewBase update.
+  // Tell the DOM element that it needs a Plugin update.
   Node* node = object.GetNode();
   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_)
@@ skipping 509 matching lines @@
         !constraints_map.at(layer).HasAncestorStickyElement()) {
       // TODO(skobes): Resolve circular dependency between scroll offset and
       // compositing state, and remove this disabler. https://crbug.com/420741
       DisableCompositingQueryAsserts disabler;
       layer->UpdateLayerPositionsAfterOverflowScroll();
       layout_object->SetMayNeedPaintInvalidationSubtree();
     }
   }
 
   // If there fixed position elements, scrolling may cause compositing layers to
-  // change.  Update FrameViewBase and layer positions after scrolling, but only
+  // change.  Update FrameView and layer positions after scrolling, but only
   // if we're not inside of layout.
   if (!nested_layout_count_) {
     UpdateGeometries();
     LayoutViewItem layout_view_item = this->GetLayoutViewItem();
     if (!layout_view_item.IsNull())
       layout_view_item.Layer()->SetNeedsCompositingInputsUpdate();
   }
 }
 
 bool FrameView::ComputeCompositedSelection(LocalFrame& frame,
@@ skipping 407 matching lines @@
   }
 
   // The fragment anchor should only be maintained while the frame is still
   // loading.  If the frame is done loading, clear the anchor now. Otherwise,
   // restore it since it may have been cleared during scrollRectToVisible.
   fragment_anchor_ =
       frame_->GetDocument()->IsLoadCompleted() ? nullptr : anchor_node;
 }
 
 bool FrameView::UpdatePlugins() {
-  // This is always called from updatePluginsTimerFired.
-  // m_updatePluginsTimer should only be scheduled if we have FrameViewBases to
+  // This is always called from UpdatePluginsTimerFired.
+  // update_plugins_timer should only be scheduled if we have FrameViews to
   // update. Thus I believe we can stop checking isEmpty here, and just ASSERT
   // isEmpty:
   // FIXME: This assert has been temporarily removed due to
   // https://crbug.com/430344
   if (nested_layout_count_ > 1 || part_update_set_.IsEmpty())
     return true;
 
   // Need to swap because script will run inside the below loop and invalidate
   // the iterator.
   EmbeddedObjectSet objects;
@@ skipping 248 matching lines @@
     return kNotScrollableExplicitlyDisabled;
 
   return kScrollable;
 }
 
 void FrameView::UpdateParentScrollableAreaSet() {
   if (RuntimeEnabledFeatures::rootLayerScrollingEnabled())
     return;
 
   // That ensures that only inner frames are cached.
-  FrameView* parent_frame_view = this->ParentFrameView();
+  FrameView* parent_frame_view = ParentFrameView();
   if (!parent_frame_view)
     return;
 
   if (!IsScrollable()) {
     parent_frame_view->RemoveScrollableArea(this);
     return;
   }
 
   parent_frame_view->AddScrollableArea(this);
 }
@@ skipping 621 matching lines @@
   if (NeedsLayout())
     UpdateLayout();
 
   CheckDoesNotNeedLayout();
 
   // WebView plugins need to update regardless of whether the
   // LayoutEmbeddedObject that owns them needed layout.
   // TODO(leviw): This currently runs the entire lifecycle on plugin WebViews.
   // We should have a way to only run these other Documents to the same
   // lifecycle stage as this frame.
-  for (const Member<PluginView>& plugin : *Plugins()) {
-    plugin->UpdateAllLifecyclePhases();
+  for (const auto& child : children_) {
+    if (child->IsPluginView())
+      ToPluginView(child)->UpdateAllLifecyclePhases();
   }
   CheckDoesNotNeedLayout();
 
   // FIXME: Calling layout() shouldn't trigger script execution or have any
   // observable effects on the frame tree but we're not quite there yet.
   HeapVector<Member<FrameView>> frame_views;
   for (Frame* child = frame_->Tree().FirstChild(); child;
        child = child->Tree().NextSibling()) {
     if (!child->IsLocalFrame())
       continue;
@@ skipping 231 matching lines @@
 IntPoint FrameView::ConvertToLayoutItem(const LayoutItem& layout_item,
                                         const IntPoint& frame_point) const {
   IntPoint point = frame_point;
 
   // Convert from FrameView coords into page ("absolute") coordinates.
   point += IntSize(ScrollX(), ScrollY());
 
   return RoundedIntPoint(layout_item.AbsoluteToLocal(point, kUseTransforms));
 }
 
-IntPoint FrameView::ConvertSelfToChild(const FrameViewBase* child,
+IntPoint FrameView::ConvertSelfToChild(const FrameOrPlugin& child,
                                        const IntPoint& point) const {
   IntPoint new_point = point;
   new_point = FrameToContents(point);
-  new_point.MoveBy(-child->Location());
+  new_point.MoveBy(child.FrameRect().Location());
   return new_point;
 }
 
 IntRect FrameView::ConvertToContainingFrameViewBase(
     const IntRect& local_rect) const {
   if (parent_) {
     // 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 local_rect;
 }
 
 IntRect FrameView::ConvertFromContainingFrameViewBase(
     const IntRect& parent_rect) const {
   if (parent_) {
     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_) {
     // Get our layoutObject in the parent view
@@ skipping 143 matching lines @@
     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);
 }
 
-void FrameView::SetParent(FrameViewBase* parent_frame_view_base) {
-  FrameView* parent = ToFrameView(parent_frame_view_base);
+void FrameView::SetParent(FrameView* parent) {
   if (parent == parent_)
     return;
 
   DCHECK(!parent || !parent_);
   if (!parent || !parent->IsVisible())
     SetParentVisible(false);
   parent_ = parent;
   if (parent && parent->IsVisible())
     SetParentVisible(true);
 
   UpdateParentScrollableAreaSet();
   SetupRenderThrottling();
 
   if (ParentFrameView())
     subtree_throttled_ = ParentFrameView()->CanThrottleRendering();
 }
 
-void FrameView::RemoveChild(FrameViewBase* child) {
+void FrameView::AddChild(FrameOrPlugin* child) {
+  DCHECK(child != this && !child->Parent());
+  child->SetParent(this);
+  children_.insert(child);
+}
+
+void FrameView::RemoveChild(FrameOrPlugin* child) {
   DCHECK(child->Parent() == this);
 
   if (child->IsFrameView() &&
       !RuntimeEnabledFeatures::rootLayerScrollingEnabled())
     RemoveScrollableArea(ToFrameView(child));
 
   child->SetParent(nullptr);
   children_.erase(child);
 }
 
-void FrameView::RemovePlugin(PluginView* plugin) {
-  DCHECK(plugin->Parent() == this);
-  DCHECK(plugins_.Contains(plugin));
-  plugin->SetParent(nullptr);
-  plugins_.erase(plugin);
-}
-
-void FrameView::AddPlugin(PluginView* plugin) {
-  DCHECK(!plugin->Parent());
-  DCHECK(!plugins_.Contains(plugin));
-  plugin->SetParent(this);
-  plugins_.insert(plugin);
-}
-
 void FrameView::RemoveScrollbar(Scrollbar* scrollbar) {
   DCHECK(scrollbars_.Contains(scrollbar));
   scrollbar->SetParent(nullptr);
   scrollbars_.erase(scrollbar);
 }
 
 void FrameView::AddScrollbar(Scrollbar* scrollbar) {
   DCHECK(!scrollbars_.Contains(scrollbar));
   scrollbar->SetParent(this);
   scrollbars_.insert(scrollbar);
@@ skipping 28 matching lines @@
   page->GetChromeClient().SetCursor(cursor, frame_);
 }
 
 void FrameView::FrameRectsChanged() {
   TRACE_EVENT0("blink", "FrameView::frameRectsChanged");
   if (LayoutSizeFixedToFrameSize())
     SetLayoutSizeInternal(FrameRect().Size());
 
   for (const auto& child : children_)
     child->FrameRectsChanged();
-
-  for (const auto& plugin : plugins_)
-    plugin->FrameRectsChanged();
 }
 
 void FrameView::SetLayoutSizeInternal(const IntSize& size) {
   if (layout_size_ == size)
     return;
 
   layout_size_ = size;
   ContentsResized();
 }
 
@@ skipping 29 matching lines @@
   TopDocumentRootScrollerController& controller =
       page->GlobalRootScrollerController();
   if (layout_viewport == controller.RootScrollerArea())
     visible_size = controller.RootScrollerVisibleArea();
 
   IntSize maximum_offset =
       ToIntSize(-ScrollOrigin() + (content_bounds - visible_size));
   return maximum_offset.ExpandedTo(MinimumScrollOffsetInt());
 }
 
-void FrameView::AddChild(FrameViewBase* child) {
-  DCHECK(child != this && !child->Parent());
-  child->SetParent(this);
-  children_.insert(child);
-}
-
 void FrameView::SetScrollbarModes(ScrollbarMode horizontal_mode,
                                   ScrollbarMode vertical_mode,
                                   bool horizontal_lock,
                                   bool vertical_lock) {
   bool needs_update = false;
 
   // If the page's overflow setting has disabled scrolling, do not allow
   // anything to override that setting, http://crbug.com/426447
   LayoutObject* viewport = ViewportLayoutObject();
   if (viewport && !ShouldIgnoreOverflowHidden()) {
@@ skipping 428 matching lines @@
 
   if (!ScrollContentsFastPath(-scroll_delta))
     ScrollContentsSlowPath();
 
   if (RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled() &&
       !RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
     // Need to update scroll translation property.
     SetNeedsPaintPropertyUpdate();
   }
 
-  // This call will move children with native FrameViewBases (plugins) and
+  // This call will move children with native FrameViews (plugins) and
   // invalidate them as well.
   FrameRectsChanged();
 }
 
 IntPoint FrameView::ContentsToFrame(
     const IntPoint& point_in_content_space) const {
   return point_in_content_space - ScrollOffsetInt();
 }
 
 IntRect FrameView::ContentsToFrame(const IntRect& rect_in_content_space) const {
@@ skipping 326 matching lines @@
   // and potentially child frame views.
   SetNeedsCompositingUpdate(GetLayoutViewItem(), kCompositingUpdateRebuildTree);
 
   parent_visible_ = visible;
 
   if (!IsSelfVisible())
     return;
 
   for (const auto& child : children_)
     child->SetParentVisible(visible);
-
-  for (const auto& plugin : plugins_)
-    plugin->SetParentVisible(visible);
 }
 
 void FrameView::Show() {
   if (!IsSelfVisible()) {
     SetSelfVisible(true);
     if (ScrollingCoordinator* scrolling_coordinator =
             this->GetScrollingCoordinator())
       scrolling_coordinator->FrameViewVisibilityDidChange();
     SetNeedsCompositingUpdate(GetLayoutViewItem(),
                               kCompositingUpdateRebuildTree);
     UpdateParentScrollableAreaSet();
     if (RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled() &&
         !RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
       // The existance of scrolling properties depends on visibility through
       // isScrollable() so ensure properties are updated if visibility changes.
       SetNeedsPaintPropertyUpdate();
     }
     if (IsParentVisible()) {
       for (const auto& child : children_)
         child->SetParentVisible(true);
-
-      for (const auto& plugin : plugins_)
-        plugin->SetParentVisible(true);
     }
   }
 }
 
 void FrameView::Hide() {
   if (IsSelfVisible()) {
     if (IsParentVisible()) {
       for (const auto& child : children_)
         child->SetParentVisible(false);
-
-      for (const auto& plugin : plugins_)
-        plugin->SetParentVisible(false);
     }
     SetSelfVisible(false);
     if (ScrollingCoordinator* scrolling_coordinator =
             this->GetScrollingCoordinator())
       scrolling_coordinator->FrameViewVisibilityDidChange();
     SetNeedsCompositingUpdate(GetLayoutViewItem(),
                               kCompositingUpdateRebuildTree);
     UpdateParentScrollableAreaSet();
     if (RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled() &&
         !RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
@@ skipping 46 matching lines @@
     return;
 
   layout_object.AddAnnotatedRegions(regions);
   for (LayoutObject* curr = layout_object.SlowFirstChild(); curr;
        curr = curr->NextSibling())
     CollectAnnotatedRegions(*curr, regions);
 }
 
 void FrameView::UpdateViewportIntersectionsForSubtree(
     DocumentLifecycle::LifecycleState target_state) {
-  // TODO(dcheng): Since FrameViewBase tree updates are deferred, FrameViews
-  // might still be in the FrameViewBase hierarchy even though the associated
+  // TODO(dcheng): Since FrameView tree updates are deferred, FrameViews
+  // might still be in the FrameView hierarchy even though the associated
   // Document is already detached. Investigate if this check and a similar check
   // in lifecycle updates are still needed when there are no more deferred
-  // FrameViewBase updates: https://crbug.com/561683
+  // FrameView updates: https://crbug.com/561683
   if (!GetFrame().GetDocument()->IsActive())
     return;
 
   if (target_state == DocumentLifecycle::kPaintClean) {
     RecordDeferredLoadingStats();
     if (!NeedsLayout()) {
       // Notify javascript IntersectionObservers
       if (GetFrame().GetDocument()->GetIntersectionObserverController()) {
         GetFrame()
             .GetDocument()
@@ skipping 60 matching lines @@
 
   // If this FrameView became unthrottled or throttled, we must make sure all
   // its children are notified synchronously. Otherwise we 1) might attempt to
   // paint one of the children with an out-of-date layout before
   // |updateRenderThrottlingStatus| has made it throttled or 2) fail to
   // unthrottle a child whose parent is unthrottled by a later notification.
   if (notify_children_behavior == kNotifyChildren &&
       (was_throttled != is_throttled ||
        force_throttling_invalidation_behavior ==
            kForceThrottlingInvalidation)) {
-    for (const Member<FrameViewBase>& child : *Children()) {
+    for (const auto& child : children_) {
       if (child->IsFrameView()) {
-        FrameView* child_view = ToFrameView(child);
-        child_view->UpdateRenderThrottlingStatus(
-            child_view->hidden_for_throttling_, is_throttled);
+        ToFrameView(child)->UpdateRenderThrottlingStatus(
+            ToFrameView(child)->hidden_for_throttling_, is_throttled);
       }
     }
   }
 
   ScrollingCoordinator* scrolling_coordinator = this->GetScrollingCoordinator();
   if (became_unthrottled ||
       force_throttling_invalidation_behavior == kForceThrottlingInvalidation) {
     // ScrollingCoordinator needs to update according to the new throttling
     // status.
     if (scrolling_coordinator)
@@ skipping 391 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