Move methods from FrameViewBase to FrameView.

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 150 matching lines @@
 
 using namespace HTMLNames;
 
 // The maximum number of updatePlugins iterations that should be done before
 // 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)
+FrameView::FrameView(LocalFrame& frame, IntRect frame_rect)

[dcheng, 2017/04/26 08:42:59]

Btw, this should be passed by const ref (followup is OK if that's easier)

[joelhockey, 2017/04/26 10:37:57]

OK, I'll follow up with this

     : frame_(frame),
+      frame_rect_(frame_rect),
+      parent_(nullptr),
       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 26 matching lines @@
       scroll_anchor_(this),
       scrollbar_manager_(*this),
       needs_scrollbars_update_(false),
       suppress_adjust_view_size_(false),
       allows_layout_invalidation_after_layout_clean_(true),
       main_thread_scrolling_reasons_(0) {
   Init();
 }
 
 FrameView* FrameView::Create(LocalFrame& frame) {
-  FrameView* view = new FrameView(frame);
+  FrameView* view = new FrameView(frame, IntRect());
   view->Show();
   return view;
 }
 
 FrameView* FrameView::Create(LocalFrame& frame, const IntSize& initial_size) {
-  FrameView* view = new FrameView(frame);
-  view->FrameViewBase::SetFrameRect(IntRect(view->Location(), 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_);
 }
 
 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_);
@@ skipping 288 matching lines @@
   IntRect paint_invalidation_rect = rect;
   paint_invalidation_rect.Move(
       (layout_item.BorderLeft() + layout_item.PaddingLeft()).ToInt(),
       (layout_item.BorderTop() + layout_item.PaddingTop()).ToInt());
   // FIXME: We should not allow paint invalidation out of paint invalidation
   // state. crbug.com/457415
   DisablePaintInvalidationStateAsserts paint_invalidation_assert_disabler;
   layout_item.InvalidatePaintRectangle(LayoutRect(paint_invalidation_rect));
 }
 
-void FrameView::SetFrameRect(const IntRect& new_rect) {
-  IntRect old_rect = FrameRect();
-  if (new_rect == old_rect)
+void FrameView::SetFrameRect(const IntRect& frame_rect) {
+  if (frame_rect == frame_rect_)
     return;
 
-  FrameViewBase::SetFrameRect(new_rect);
+  const bool width_changed = frame_rect_.Width() != frame_rect.Width();
+  const bool height_changed = frame_rect_.Height() != frame_rect.Height();
+  frame_rect_ = frame_rect;
 
-  const bool frame_size_changed = old_rect.Size() != new_rect.Size();
-
-  needs_scrollbars_update_ = frame_size_changed;
+  needs_scrollbars_update_ = width_changed || height_changed;
   // TODO(wjmaclean): find out why scrollbars fail to resize for complex
   // subframes after changing the zoom level. For now always calling
   // updateScrollbarsIfNeeded() here fixes the issue, but it would be good to
   // discover the deeper cause of this. http://crbug.com/607987.
   UpdateScrollbarsIfNeeded();
 
   FrameRectsChanged();
 
   UpdateParentScrollableAreaSet();
 
   if (RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled() &&
       !RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
     // The overflow clip property depends on the frame size and the pre
     // translation property depends on the frame location.
     SetNeedsPaintPropertyUpdate();
   }
 
   if (auto layout_view_item = this->GetLayoutViewItem())
     layout_view_item.SetMayNeedPaintInvalidation();
 
-  if (frame_size_changed) {
-    ViewportSizeChanged(new_rect.Width() != old_rect.Width(),
-                        new_rect.Height() != old_rect.Height());
+  if (width_changed || height_changed) {
+    ViewportSizeChanged(width_changed, height_changed);
 
     if (frame_->IsMainFrame())
       frame_->GetPage()->GetVisualViewport().MainFrameDidChangeSize();
 
     GetFrame().Loader().RestoreScrollPositionAndViewState();
   }
 }
 
 Page* FrameView::GetPage() const {
   return GetFrame().GetPage();
@@ skipping 3059 matching lines @@
 IntPoint FrameView::ConvertSelfToChild(const FrameViewBase* child,
                                        const IntPoint& point) const {
   IntPoint new_point = point;
   new_point = FrameToContents(point);
   new_point.MoveBy(-child->Location());
   return new_point;
 }
 
 IntRect FrameView::ConvertToContainingFrameViewBase(
     const IntRect& local_rect) const {
-  if (const FrameView* parent = ToFrameView(Parent())) {
+  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 parent_->ConvertFromLayoutItem(layout_item, rect);
   }
 
   return local_rect;
 }
 
 IntRect FrameView::ConvertFromContainingFrameViewBase(
     const IntRect& parent_rect) const {
-  if (const FrameView* parent = ToFrameView(Parent())) {
+  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 (const FrameView* parent = ToFrameView(Parent())) {
+  if (parent_) {
     // 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 (const FrameView* parent = ToFrameView(Parent())) {
+  if (parent_) {
     // 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 109 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) {
-  if (parent == Parent())
+FrameView* FrameView::Root() const {
+  const FrameView* top = this;
+  while (top->Parent())
+    top = ToFrameView(top->Parent());
+  return const_cast<FrameView*>(top);
+}
+
+void FrameView::SetParent(FrameViewBase* parent_frame_view_base) {
+  FrameView* parent = ToFrameView(parent_frame_view_base);
+  if (parent == parent_)
     return;
 
-  FrameViewBase::SetParent(parent);
+  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) {
   DCHECK(child->Parent() == this);
@@ skipping 115 matching lines @@
   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());
-  DCHECK(!child->IsPluginView());
   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;
 
@@ skipping 733 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 (const FrameView* parent = ToFrameView(Parent())) {
+  if (parent_) {
     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 (const FrameView* parent = ToFrameView(Parent())) {
+  if (parent_) {
     IntPoint parent_point = ConvertToContainingFrameViewBase(local_point);
-    return parent->ConvertToRootFrame(parent_point);
+    return parent_->ConvertToRootFrame(parent_point);
   }
   return local_point;
 }
 
 IntPoint FrameView::ConvertFromContainingFrameViewBaseToScrollbar(
     const Scrollbar& scrollbar,
     const IntPoint& parent_point) const {
   IntPoint new_point = parent_point;
   // Scrollbars won't be transformed within us
   new_point.MoveBy(-scrollbar.Location());
   return new_point;
 }
 
 static void SetNeedsCompositingUpdate(LayoutViewItem layout_view_item,
                                       CompositingUpdateType update_type) {
   if (PaintLayerCompositor* compositor =
           !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);
 
-  FrameViewBase::SetParentVisible(visible);
+  parent_visible_ = visible;
 
   if (!IsSelfVisible())
     return;
 
   for (const auto& child : children_)
     child->SetParentVisible(visible);
 
   for (const auto& plugin : plugins_)
     plugin->SetParentVisible(visible);
 }
@@ skipping 586 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