Remove FrameViewBase as base class of PluginView.

third_party/WebKit/Source/web/WebPluginContainerImpl.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2014 Opera Software ASA. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 94 matching lines @@
 #include "web/ChromeClientImpl.h"
 #include "web/WebDataSourceImpl.h"
 #include "web/WebInputEventConversion.h"
 #include "web/WebLocalFrameImpl.h"
 #include "web/WebViewImpl.h"
 
 namespace blink {
 
 // Public methods --------------------------------------------------------------
 
-void WebPluginContainerImpl::SetFrameRect(const IntRect& frame_rect) {
-  FrameViewBase::SetFrameRect(frame_rect);
+void WebPluginContainerImpl::SetParent(FrameView* parent) {
+  DCHECK(!parent || !parent_);
+  if (!parent || !parent->IsVisible())
+    SetParentVisible(false);
+  parent_ = parent;
+  if (parent && parent->IsVisible())
+    SetParentVisible(true);
 }
 
 void WebPluginContainerImpl::UpdateAllLifecyclePhases() {
   if (!web_plugin_)
     return;
 
   web_plugin_->UpdateAllLifecyclePhases();
 }
 
 void WebPluginContainerImpl::Paint(GraphicsContext& context,
                                    const CullRect& cull_rect) const {
-  if (!Parent())
+  if (!parent_)
     return;
 
   // Don't paint anything if the plugin doesn't intersect.
-  if (!cull_rect.IntersectsCullRect(FrameRect()))
+  if (!cull_rect.IntersectsCullRect(frame_rect_))
     return;
 
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled() && web_layer_) {
     // With Slimming Paint v2, composited plugins should have their layers
     // inserted rather than invoking WebPlugin::paint.
     RecordForeignLayer(context, *element_->GetLayoutObject(),
-                       DisplayItem::kForeignLayerPlugin, web_layer_, Location(),
-                       Size());
+                       DisplayItem::kForeignLayerPlugin, web_layer_,
+                       frame_rect_.Location(), frame_rect_.Size());
     return;
   }
 
   if (LayoutObjectDrawingRecorder::UseCachedDrawingIfPossible(
           context, *element_->GetLayoutObject(), DisplayItem::Type::kWebPlugin))
     return;
 
   LayoutObjectDrawingRecorder drawing_recorder(
       context, *element_->GetLayoutObject(), DisplayItem::Type::kWebPlugin,
       cull_rect.rect_);
   context.Save();
 
-  DCHECK(Parent()->IsFrameView());
-  FrameView* view = ToFrameView(Parent());
-
   // The plugin is positioned in the root frame's coordinates, so it needs to
   // be painted in them too.
-  IntPoint origin = view->ContentsToRootFrame(IntPoint(0, 0));
+  IntPoint origin = parent_->ContentsToRootFrame(IntPoint(0, 0));
   context.Translate(static_cast<float>(-origin.X()),
                     static_cast<float>(-origin.Y()));
 
   WebCanvas* canvas = context.Canvas();
 
-  IntRect window_rect = view->ContentsToRootFrame(cull_rect.rect_);
+  IntRect window_rect = parent_->ContentsToRootFrame(cull_rect.rect_);
   web_plugin_->Paint(canvas, window_rect);
 
   context.Restore();
 }
 
 void WebPluginContainerImpl::InvalidateRect(const IntRect& rect) {
-  if (!Parent())
+  if (!parent_)
     return;
 
   LayoutBox* layout_object = ToLayoutBox(element_->GetLayoutObject());
   if (!layout_object)
     return;
 
   IntRect dirty_rect = rect;
   dirty_rect.Move(
       (layout_object->BorderLeft() + layout_object->PaddingLeft()).ToInt(),
       (layout_object->BorderTop() + layout_object->PaddingTop()).ToInt());
 
   pending_invalidation_rect_.Unite(dirty_rect);
 
   layout_object->SetMayNeedPaintInvalidation();
 }
 
 void WebPluginContainerImpl::SetFocused(bool focused, WebFocusType focus_type) {
   web_plugin_->UpdateFocus(focused, focus_type);
 }
 
 void WebPluginContainerImpl::Show() {
-  SetSelfVisible(true);
+  self_visible_ = true;
   web_plugin_->UpdateVisibility(true);
-
-  FrameViewBase::Show();
 }
 
 void WebPluginContainerImpl::Hide() {
-  SetSelfVisible(false);
+  self_visible_ = false;
   web_plugin_->UpdateVisibility(false);
-
-  FrameViewBase::Hide();
 }
 
 void WebPluginContainerImpl::HandleEvent(Event* event) {
   // The events we pass are defined at:
   //    http://devedge-temp.mozilla.org/library/manuals/2002/plugin/1.0/structures5.html#1000000
   // Don't take the documentation as truth, however.  There are many cases
   // where mozilla behaves differently than the spec.
   if (event->IsMouseEvent())
     HandleMouseEvent(ToMouseEvent(event));
   else if (event->IsWheelEvent())
     HandleWheelEvent(ToWheelEvent(event));
   else if (event->IsKeyboardEvent())
     HandleKeyboardEvent(ToKeyboardEvent(event));
   else if (event->IsTouchEvent())
     HandleTouchEvent(ToTouchEvent(event));
   else if (event->IsGestureEvent())
     HandleGestureEvent(ToGestureEvent(event));
   else if (event->IsDragEvent() && web_plugin_->CanProcessDrag())
     HandleDragEvent(ToDragEvent(event));
 
   // FIXME: it would be cleaner if FrameViewBase::handleEvent returned
   // true/false and HTMLPluginElement called setDefaultHandled or
   // defaultEventHandler.
   if (!event->DefaultHandled())
     element_->Node::DefaultEventHandler(event);
 }
 
 void WebPluginContainerImpl::FrameRectsChanged() {
-  FrameViewBase::FrameRectsChanged();
   ReportGeometry();
 }
 
 void WebPluginContainerImpl::GeometryMayHaveChanged() {
-  FrameViewBase::GeometryMayHaveChanged();
   ReportGeometry();
 }
 
 void WebPluginContainerImpl::EventListenersRemoved() {
   // We're no longer registered to receive touch events, so don't try to remove
   // the touch event handlers in our destructor.
   touch_event_request_type_ = kTouchEventRequestTypeNone;
 }
 
 void WebPluginContainerImpl::SetParentVisible(bool parent_visible) {
   // We override this function to make sure that geometry updates are sent
   // over to the plugin. For e.g. when a plugin is instantiated it does not
   // have a valid parent. As a result the first geometry update from webkit
   // is ignored. This function is called when the plugin eventually gets a
   // parent.
 
-  if (IsParentVisible() == parent_visible)
+  if (parent_visible_ == parent_visible)
     return;  // No change.
 
-  FrameViewBase::SetParentVisible(parent_visible);
-  if (!IsSelfVisible())
+  parent_visible_ = parent_visible;
+  if (!self_visible_)
     return;  // This widget has explicitely been marked as not visible.
 
   if (web_plugin_)
-    web_plugin_->UpdateVisibility(IsVisible());
+    web_plugin_->UpdateVisibility(parent_visible_ && self_visible_);
 }
 
 void WebPluginContainerImpl::SetPlugin(WebPlugin* plugin) {
   if (plugin == web_plugin_)
     return;
 
   element_->ResetInstance();
   web_plugin_ = plugin;
   is_disposed_ = false;
 }
@@ skipping 133 matching lines @@
   element_->DispatchEvent(event);
 }
 
 void WebPluginContainerImpl::EnqueueMessageEvent(
     const WebDOMMessageEvent& event) {
   static_cast<Event*>(event)->SetTarget(element_);
   element_->GetExecutionContext()->GetEventQueue()->EnqueueEvent(event);
 }
 
 void WebPluginContainerImpl::Invalidate() {
-  FrameViewBase::Invalidate();
+  InvalidateRect(IntRect(0, 0, frame_rect_.Width(), frame_rect_.Height()));
 }
 
 void WebPluginContainerImpl::InvalidateRect(const WebRect& rect) {
   InvalidateRect(static_cast<IntRect>(rect));
 }
 
 void WebPluginContainerImpl::ScrollRect(const WebRect& rect) {
   InvalidateRect(rect);
 }
 
 void WebPluginContainerImpl::ScheduleAnimation() {
   if (auto* frame_view = element_->GetDocument().View())
     frame_view->ScheduleAnimation();
 }
 
 void WebPluginContainerImpl::ReportGeometry() {
   // We cannot compute geometry without a parent or layoutObject.
-  if (!Parent() || !element_ || !element_->GetLayoutObject() || !web_plugin_)
+  if (!parent_ || !element_ || !element_->GetLayoutObject() || !web_plugin_)
     return;
 
   IntRect window_rect, clip_rect, unobscured_rect;
   Vector<IntRect> cut_out_rects;
   CalculateGeometry(window_rect, clip_rect, unobscured_rect, cut_out_rects);
   web_plugin_->UpdateGeometry(window_rect, clip_rect, unobscured_rect,
-                              cut_out_rects, IsVisible());
+                              cut_out_rects, self_visible_);
 }
 
 v8::Local<v8::Object> WebPluginContainerImpl::V8ObjectForElement() {
   LocalFrame* frame = element_->GetDocument().GetFrame();
   if (!frame)
     return v8::Local<v8::Object>();
 
   if (!element_->GetDocument().CanExecuteScripts(kNotAboutToExecuteScript))
     return v8::Local<v8::Object>();
 
@@ skipping 60 matching lines @@
   // we might be being disposed because the frame has already be deleted and
   // then something else dropped the
   // last reference to the this object.
   if (is_disposed_ || !element_)
     return false;
 
   LocalFrame* frame = element_->GetDocument().GetFrame();
   if (!frame)
     return false;
 
-  IntRect document_rect(X() + rect.x, Y() + rect.y, rect.width, rect.height);
+  IntRect document_rect(frame_rect_.X() + rect.x, frame_rect_.Y() + rect.y,
+                        rect.width, rect.height);
   // hitTestResultAtPoint() takes a padding rectangle.
   // FIXME: We'll be off by 1 when the width or height is even.
   LayoutPoint center = document_rect.Center();
   // Make the rect we're checking (the point surrounded by padding rects)
   // contained inside the requested rect. (Note that -1/2 is 0.)
   LayoutSize padding((document_rect.Width() - 1) / 2,
                      (document_rect.Height() - 1) / 2);
   HitTestResult result = frame->GetEventHandler().HitTestResultAtPoint(
       center,
       HitTestRequest::kReadOnly | HitTestRequest::kActive |
@@ skipping 34 matching lines @@
                                   EventHandlerRegistry::kWheelEventBlocking);
     else
       registry.DidRemoveEventHandler(*element_,
                                      EventHandlerRegistry::kWheelEventBlocking);
   }
 
   wants_wheel_events_ = wants_wheel_events;
   if (Page* page = element_->GetDocument().GetPage()) {
     if (ScrollingCoordinator* scrolling_coordinator =
             page->GetScrollingCoordinator()) {
-      if (Parent() && Parent()->IsFrameView())
+      if (parent_)
         scrolling_coordinator->NotifyGeometryChanged();
     }
   }
 }
 
 WebPoint WebPluginContainerImpl::RootFrameToLocalPoint(
     const WebPoint& point_in_root_frame) {
-  FrameView* view = ToFrameView(Parent());
-  if (!view)
+  if (!parent_)
     return point_in_root_frame;
-  WebPoint point_in_content = view->RootFrameToContents(point_in_root_frame);
+  WebPoint point_in_content = parent_->RootFrameToContents(point_in_root_frame);
   return RoundedIntPoint(element_->GetLayoutObject()->AbsoluteToLocal(
       FloatPoint(point_in_content), kUseTransforms));
 }
 
 WebPoint WebPluginContainerImpl::LocalToRootFramePoint(
     const WebPoint& point_in_local) {
-  FrameView* view = ToFrameView(Parent());
-  if (!view)
+  if (!parent_)
     return point_in_local;
   IntPoint absolute_point =
       RoundedIntPoint(element_->GetLayoutObject()->LocalToAbsolute(
           FloatPoint(point_in_local), kUseTransforms));
-  return view->ContentsToRootFrame(absolute_point);
+  return parent_->ContentsToRootFrame(absolute_point);
 }
 
 void WebPluginContainerImpl::DidReceiveResponse(
     const ResourceResponse& response) {
   // Make sure that the plugin receives window geometry before data, or else
   // plugins misbehave.
   FrameRectsChanged();
 
   WrappedResourceResponse url_response(response);
   web_plugin_->DidReceiveResponse(url_response);
@@ skipping 53 matching lines @@
 // Private methods -------------------------------------------------------------
 
 WebPluginContainerImpl::WebPluginContainerImpl(HTMLPlugInElement* element,
                                                WebPlugin* web_plugin)
     : ContextClient(element->GetDocument().GetFrame()),
       element_(element),
       web_plugin_(web_plugin),
       web_layer_(nullptr),
       touch_event_request_type_(kTouchEventRequestTypeNone),
       wants_wheel_events_(false),
+      self_visible_(false),
+      parent_visible_(false),
       is_disposed_(false) {}
 
 WebPluginContainerImpl::~WebPluginContainerImpl() {
   // The plugin container must have been disposed of by now.
   DCHECK(!web_plugin_);
 }
 
 void WebPluginContainerImpl::Dispose() {
   is_disposed_ = true;
 
   RequestTouchEventType(kTouchEventRequestTypeNone);
   SetWantsWheelEvents(false);
 
   if (web_plugin_) {
     CHECK(web_plugin_->Container() == this);
     web_plugin_->Destroy();
     web_plugin_ = nullptr;
   }
 
   if (web_layer_) {
     GraphicsLayer::UnregisterContentsLayer(web_layer_);
     web_layer_ = nullptr;
   }
 }
 
 DEFINE_TRACE(WebPluginContainerImpl) {
+  visitor->Trace(parent_);
   visitor->Trace(element_);
   ContextClient::Trace(visitor);
   PluginView::Trace(visitor);
 }
 
 void WebPluginContainerImpl::HandleMouseEvent(MouseEvent* event) {
-  DCHECK(Parent()->IsFrameView());
-
   // We cache the parent FrameView here as the plugin widget could be deleted
   // in the call to HandleEvent. See http://b/issue?id=1362948
-  FrameView* parent_view = ToFrameView(Parent());
+  FrameView* parent_view = parent_;
 
   // TODO(dtapuska): Move WebMouseEventBuilder into the anonymous namespace
   // in this class.
   WebMouseEventBuilder transformed_event(
-      ToFrameView(Parent()), LayoutItem(element_->GetLayoutObject()), *event);
+      parent_, LayoutItem(element_->GetLayoutObject()), *event);
   if (transformed_event.GetType() == WebInputEvent::kUndefined)
     return;
 
   if (event->type() == EventTypeNames::mousedown)
     FocusPlugin();
 
   WebCursorInfo cursor_info;
   if (web_plugin_ &&
       web_plugin_->HandleInputEvent(transformed_event, cursor_info) !=
           WebInputEventResult::kNotHandled)
@@ skipping 24 matching lines @@
     drag_status = kWebDragStatusDrop;
 
   if (drag_status == kWebDragStatusUnknown)
     return;
 
   DataTransfer* data_transfer = event->getDataTransfer();
   WebDragData drag_data = data_transfer->GetDataObject()->ToWebDragData();
   WebDragOperationsMask drag_operation_mask =
       static_cast<WebDragOperationsMask>(data_transfer->SourceOperation());
   WebPoint drag_screen_location(event->screenX(), event->screenY());
-  WebPoint drag_location(event->AbsoluteLocation().X() - Location().X(),
-                         event->AbsoluteLocation().Y() - Location().Y());
+  WebPoint drag_location(
+      event->AbsoluteLocation().X() - frame_rect_.Location().X(),
+      event->AbsoluteLocation().Y() - frame_rect_.Location().Y());
 
   web_plugin_->HandleDragStatusUpdate(drag_status, drag_data,
                                       drag_operation_mask, drag_location,
                                       drag_screen_location);
 }
 
 void WebPluginContainerImpl::HandleWheelEvent(WheelEvent* event) {
   WebFloatPoint absolute_location = event->NativeEvent().PositionInRootFrame();
 
-  FrameView* view = ToFrameView(Parent());
   // Translate the root frame position to content coordinates.
-  if (view) {
-    absolute_location = view->RootFrameToContents(absolute_location);
+  if (parent_) {
+    absolute_location = parent_->RootFrameToContents(absolute_location);
   }
 
   IntPoint local_point =
       RoundedIntPoint(element_->GetLayoutObject()->AbsoluteToLocal(
           absolute_location, kUseTransforms));
   WebMouseWheelEvent translated_event = event->NativeEvent().FlattenTransform();
   translated_event.SetPositionInWidget(local_point.X(), local_point.Y());
 
   WebCursorInfo cursor_info;
   if (web_plugin_->HandleInputEvent(translated_event, cursor_info) !=
@@ skipping 45 matching lines @@
     case kTouchEventRequestTypeRaw: {
       if (!event->NativeEvent())
         return;
 
       if (event->type() == EventTypeNames::touchstart)
         FocusPlugin();
 
       WebTouchEvent transformed_event =
           event->NativeEvent()->FlattenTransform();
 
-      FrameView* view = ToFrameView(Parent());
-
       for (unsigned i = 0; i < transformed_event.touches_length; ++i) {
         WebFloatPoint absolute_location = transformed_event.touches[i].position;
 
         // Translate the root frame position to content coordinates.
-        if (view) {
-          absolute_location = view->RootFrameToContents(absolute_location);
+        if (parent_) {
+          absolute_location = parent_->RootFrameToContents(absolute_location);
         }
 
         IntPoint local_point =
             RoundedIntPoint(element_->GetLayoutObject()->AbsoluteToLocal(
                 absolute_location, kUseTransforms));
         transformed_event.touches[i].position.x = local_point.X();
         transformed_event.touches[i].position.y = local_point.Y();
       }
 
       WebCursorInfo cursor_info;
@@ skipping 32 matching lines @@
       WebInputEventResult::kNotHandled) {
     event->SetDefaultHandled();
     return;
   }
 
   // FIXME: Can a plugin change the cursor from a touch-event callback?
 }
 
 void WebPluginContainerImpl::SynthesizeMouseEventIfPossible(TouchEvent* event) {
   WebMouseEventBuilder web_event(
-      ToFrameView(Parent()), LayoutItem(element_->GetLayoutObject()), *event);
+      parent_, LayoutItem(element_->GetLayoutObject()), *event);
   if (web_event.GetType() == WebInputEvent::kUndefined)
     return;
 
   WebCursorInfo cursor_info;
   if (web_plugin_->HandleInputEvent(web_event, cursor_info) !=
       WebInputEventResult::kNotHandled)
     event->SetDefaultHandled();
 }
 
 void WebPluginContainerImpl::FocusPlugin() {
-  LocalFrame& containing_frame = ToFrameView(Parent())->GetFrame();
+  LocalFrame& containing_frame = parent_->GetFrame();
   if (Page* current_page = containing_frame.GetPage())
     current_page->GetFocusController().SetFocusedElement(element_,
                                                          &containing_frame);
   else
     containing_frame.GetDocument()->SetFocusedElement(
         element_, FocusParams(SelectionBehaviorOnFocus::kNone,
                               kWebFocusTypeNone, nullptr));
 }
 
 void WebPluginContainerImpl::IssuePaintInvalidations() {
@@ skipping 21 matching lines @@
     unclipped_int_local_rect = IntRect();
     return;
   }
 
   LayoutView* root_view = element_->GetDocument().View()->GetLayoutView();
   while (root_view->GetFrame()->OwnerLayoutObject())
     root_view = root_view->GetFrame()->OwnerLayoutObject()->View();
 
   LayoutBox* box = ToLayoutBox(owner_element->GetLayoutObject());
 
-  // Note: frameRect() for this plugin is equal to contentBoxRect, mapped to the
+  // Note: FrameRect() for this plugin is equal to contentBoxRect, mapped to the
   // containing view space, and rounded off.
   // See LayoutPart.cpp::updateGeometryInternal. To remove the lossy
   // effect of rounding off, use contentBoxRect directly.
   LayoutRect unclipped_absolute_rect(box->ContentBoxRect());
   box->MapToVisualRectInAncestorSpace(root_view, unclipped_absolute_rect);
 
   // The frameRect is already in absolute space of the local frame to the
   // plugin.
-  window_rect = FrameRect();
+  window_rect = frame_rect_;
   // Map up to the root frame.
   LayoutRect layout_window_rect =
       LayoutRect(element_->GetDocument()
                      .View()
                      ->GetLayoutViewItem()
-                     .LocalToAbsoluteQuad(FloatQuad(FloatRect(FrameRect())),
+                     .LocalToAbsoluteQuad(FloatQuad(FloatRect(frame_rect_)),
                                           kTraverseDocumentBoundaries)
                      .BoundingBox());
   // Finally, adjust for scrolling of the root frame, which the above does not
   // take into account.
   layout_window_rect.MoveBy(-root_view->ViewRect().Location());
   window_rect = PixelSnappedIntRect(layout_window_rect);
 
   LayoutRect layout_clipped_local_rect = unclipped_absolute_rect;
   LayoutRect unclipped_layout_local_rect = layout_clipped_local_rect;
   layout_clipped_local_rect.Intersect(
@@ skipping 23 matching lines @@
   // FIXME: Can we just check m_element->document().isActive() ?
   if (!element_->GetLayoutObject()
            ->GetDocument()
            .GetLayoutViewItem()
            .IsNull()) {
     // Take our element and get the clip rect from the enclosing layer and
     // frame view.
     ComputeClipRectsForPlugin(element_, window_rect, clip_rect,
                               unobscured_rect);
   }
-  GetPluginOcclusions(element_, this->Parent(), FrameRect(), cut_out_rects);
+  GetPluginOcclusions(element_, parent_, frame_rect_, cut_out_rects);
   // Convert to the plugin position.
   for (size_t i = 0; i < cut_out_rects.size(); i++)
-    cut_out_rects[i].Move(-FrameRect().X(), -FrameRect().Y());
+    cut_out_rects[i].Move(-frame_rect_.X(), -frame_rect_.Y());
 }
 
 }  // namespace blink