Remove FrameViewBase as base class of PluginView.

third_party/WebKit/Source/core/layout/LayoutPart.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Simon Hausmann <hausmann@kde.org>
  *           (C) 2000 Stefan Schimanski (1Stein@gmx.de)
  * Copyright (C) 2004, 2005, 2006, 2009 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #include "core/layout/LayoutPart.h"
 
 #include "core/dom/AXObjectCache.h"
+#include "core/frame/FrameOrPlugin.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
+#include "core/frame/RemoteFrameView.h"
 #include "core/html/HTMLFrameElementBase.h"
 #include "core/html/HTMLPlugInElement.h"
 #include "core/layout/HitTestResult.h"
 #include "core/layout/LayoutAnalyzer.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/api/LayoutAPIShim.h"
 #include "core/layout/api/LayoutViewItem.h"
 #include "core/paint/PartPainter.h"
 #include "core/plugins/PluginView.h"
 
@@ skipping 61 matching lines @@
   return nullptr;
 }
 
 PluginView* LayoutPart::Plugin() const {
   // Plugins are stored in HTMLPlugInElement node.
   Node* node = GetNode();
   return node && IsHTMLPlugInElement(node) ? ToHTMLPlugInElement(node)->Plugin()
                                            : nullptr;
 }
 
-FrameViewBase* LayoutPart::PluginOrFrame() const {
-  FrameViewBase* result = nullptr;
+FrameOrPlugin* LayoutPart::GetFrameOrPlugin() const {
   Node* node = GetNode();
-  if (node && node->IsFrameOwnerElement())
-    result = ToHTMLFrameOwnerElement(node)->OwnedWidget();
-  if (!result)
-    result = Plugin();
-  return result;
+  if (node && node->IsFrameOwnerElement()) {
+    FrameViewBase* frame_view_base =
+        ToHTMLFrameOwnerElement(node)->OwnedWidget();
+    if (frame_view_base) {
+      if (frame_view_base->IsFrameView())
+        return ToFrameView(frame_view_base);
+      if (frame_view_base->IsRemoteFrameView())
+        return ToRemoteFrameView(frame_view_base);

[dcheng, 2017/04/17 21:09:05]

This is another example of something that would be simpler of FrameViewBase just
subclasses FrameOrPlugin.

[joelhockey, 2017/04/18 00:42:41]

That is true, but it will be even better when FrameViewBase is removed, and the
common class of Plugin, FrameView, and RemoteFrameView is in /core/frame rather
than platform.

+      // Must be either FrameView or RemoteFrameView.
+      NOTREACHED();
+    }
+  }
+  return Plugin();
 }
 
 PaintLayerType LayoutPart::LayerTypeRequired() const {
   PaintLayerType type = LayoutReplaced::LayerTypeRequired();
   if (type != kNoPaintLayer)
     return type;
   return kForcedPaintLayer;
 }
 
 bool LayoutPart::RequiresAcceleratedCompositing() const {
@@ skipping 123 matching lines @@
 
 CompositingReasons LayoutPart::AdditionalCompositingReasons() const {
   if (RequiresAcceleratedCompositing())
     return kCompositingReasonIFrame;
   return kCompositingReasonNone;
 }
 
 void LayoutPart::StyleDidChange(StyleDifference diff,
                                 const ComputedStyle* old_style) {
   LayoutReplaced::StyleDidChange(diff, old_style);
-  FrameViewBase* frame_view_base = this->PluginOrFrame();
-  if (!frame_view_base)
+  FrameOrPlugin* frame_or_plugin = GetFrameOrPlugin();
+  if (!frame_or_plugin)
     return;
 
   // If the iframe has custom scrollbars, recalculate their style.
-  if (frame_view_base->IsFrameView())
-    ToFrameView(frame_view_base)->RecalculateCustomScrollbarStyle();
+  if (FrameView* frame_view = ChildFrameView())
+    frame_view->RecalculateCustomScrollbarStyle();
 
   if (Style()->Visibility() != EVisibility::kVisible) {
-    frame_view_base->Hide();
+    frame_or_plugin->Hide();
   } else {
-    frame_view_base->Show();
+    frame_or_plugin->Show();
   }
 }
 
 void LayoutPart::UpdateLayout() {
   DCHECK(NeedsLayout());
   LayoutAnalyzer::Scope analyzer(*this);
   ClearNeedsLayout();
 }
 
 void LayoutPart::Paint(const PaintInfo& paint_info,
@@ skipping 21 matching lines @@
   // rect is snapped at the document boundary, and sub-pixel movement could
   // cause the sub-frame to layout due to the 1px snap difference. In order to
   // avoid that, the size of sub-frame is rounded in advance.
   LayoutRect size_rounded_rect = ContentBoxRect();
   size_rounded_rect.SetSize(
       LayoutSize(RoundedIntSize(size_rounded_rect.Size())));
   return size_rounded_rect;
 }
 
 void LayoutPart::UpdateOnWidgetChange() {
-  FrameViewBase* frame_view_base = this->PluginOrFrame();
-  if (!frame_view_base)
+  FrameOrPlugin* frame_or_plugin = GetFrameOrPlugin();
+  if (!frame_or_plugin)
     return;
 
   if (!Style())
     return;
 
   if (!NeedsLayout())
-    UpdateGeometryInternal(*frame_view_base);
+    UpdateGeometryInternal(*frame_or_plugin);
 
   if (Style()->Visibility() != EVisibility::kVisible) {
-    frame_view_base->Hide();
+    frame_or_plugin->Hide();
   } else {
-    frame_view_base->Show();
+    frame_or_plugin->Show();
     // FIXME: Why do we issue a full paint invalidation in this case, but not
     // the other?
     SetShouldDoFullPaintInvalidation();
   }
 }
 
 void LayoutPart::UpdateGeometry() {
-  FrameViewBase* frame_view_base = this->PluginOrFrame();
-  if (!frame_view_base ||
-      !GetNode())  // Check the node in case destroy() has been called.
+  FrameOrPlugin* frame_or_plugin = GetFrameOrPlugin();
+  if (!frame_or_plugin)
     return;
 
   LayoutRect new_frame = ReplacedContentRect();
   DCHECK(new_frame.Size() == RoundedIntSize(new_frame.Size()));
   bool bounds_will_change =
-      LayoutSize(frame_view_base->FrameRect().Size()) != new_frame.Size();
-
-  FrameView* frame_view =
-      frame_view_base->IsFrameView() ? ToFrameView(frame_view_base) : nullptr;
+      LayoutSize(frame_or_plugin->FrameRect().Size()) != new_frame.Size();
 
   // If frame bounds are changing mark the view for layout. Also check the
   // frame's page to make sure that the frame isn't in the process of being
   // destroyed. If iframe scrollbars needs reconstruction from native to custom
   // scrollbar, then also we need to layout the frameview.
+  FrameView* frame_view = ChildFrameView();
   if (frame_view && frame_view->GetFrame().GetPage() &&
       (bounds_will_change || frame_view->NeedsScrollbarReconstruction()))
     frame_view->SetNeedsLayout();
 
-  UpdateGeometryInternal(*frame_view_base);
+  UpdateGeometryInternal(*frame_or_plugin);
 
   // If view needs layout, either because bounds have changed or possibly
   // indicating content size is wrong, we have to do a layout to set the right
-  // FrameViewBase size.
+  // FrameView size.
   if (frame_view && frame_view->NeedsLayout() &&
       frame_view->GetFrame().GetPage())
     frame_view->UpdateLayout();
 
-  frame_view_base->GeometryMayHaveChanged();
+  if (PluginView* plugin = Plugin())
+    plugin->GeometryMayHaveChanged();
 }
 
-void LayoutPart::UpdateGeometryInternal(FrameViewBase& frame_view_base) {
+void LayoutPart::UpdateGeometryInternal(FrameOrPlugin& frame_or_plugin) {
   // Ignore transform here, as we only care about the sub-pixel accumulation.
   // TODO(trchen): What about multicol? Need a LayoutBox function to query
   // sub-pixel accumulation.
   LayoutPoint absolute_location(LocalToAbsolute(FloatPoint()));
   LayoutRect absolute_replaced_rect = ReplacedContentRect();
   absolute_replaced_rect.MoveBy(absolute_location);
 
   IntRect frame_rect(IntPoint(),
                      PixelSnappedIntRect(absolute_replaced_rect).Size());
   // Normally the location of the frame rect is ignored by the painter, but
   // currently it is still used by a family of coordinate conversion function in
-  // FrameViewBase/FrameView. This is incorrect because coordinate conversion
+  // FrameView. This is incorrect because coordinate conversion
   // needs to take transform and into account. A few callers still use the
   // family of conversion function, including but not exhaustive:
   // FrameView::updateViewportIntersectionIfNeeded()
   // RemoteFrameView::frameRectsChanged().
   // WebPluginContainerImpl::reportGeometry()
   // TODO(trchen): Remove this hack once we fixed all callers.
   FloatRect absolute_bounding_box =
       LocalToAbsoluteQuad(FloatRect(ReplacedContentRect())).BoundingBox();
   frame_rect.SetLocation(RoundedIntPoint(absolute_bounding_box.Location()));
 
   // Why is the protector needed?
   RefPtr<LayoutPart> protector(this);
-  frame_view_base.SetFrameRect(frame_rect);
+  frame_or_plugin.SetFrameRect(frame_rect);
 }
 
 void LayoutPart::InvalidatePaintOfSubtreesIfNeeded(
     const PaintInvalidationState& paint_invalidation_state) {
   FrameView* frame_view = ChildFrameView();
   if (frame_view && !IsThrottledFrameView()) {
     // |childFrameView| is in another document, which could be
     // missing its LayoutView. TODO(jchaffraix): Ideally we should
     // not need this code.
     if (LayoutView* child_layout_view = ToLayoutView(
             LayoutAPIShim::LayoutObjectFrom(frame_view->GetLayoutViewItem()))) {
       PaintInvalidationState child_view_paint_invalidation_state(
           paint_invalidation_state, *child_layout_view);
       frame_view->InvalidateTreeIfNeeded(child_view_paint_invalidation_state);
     }
   }
 
   LayoutReplaced::InvalidatePaintOfSubtreesIfNeeded(paint_invalidation_state);
 }
 
 bool LayoutPart::IsThrottledFrameView() const {
   if (FrameView* frame_view = ChildFrameView())
     return frame_view->ShouldThrottleRendering();
   return false;
 }
 
 }  // namespace blink