Delete widget tree (FrameView::parent_)

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 "public/web/WebPlugin.h"
 #include "public/web/WebPrintParams.h"
 #include "public/web/WebPrintPresetOptions.h"
 #include "public/web/WebViewClient.h"
 
 namespace blink {
 
 // Public methods --------------------------------------------------------------
 
 void WebPluginContainerImpl::SetParent(FrameView* parent) {
+  if (parent) {
+    SetFrameOrPluginState(kAttached);
+    DCHECK(parent == ParentFrameView());
+  }
+  if (!parent) {
+    DCHECK(plugin_state_ == kAttached ||
+           (plugin_state_ == kDisposed && parent_));
+    SetFrameOrPluginState(kNotAttached);
+  }
+
   DCHECK(!parent || !parent_);
   if (!parent || !parent->IsVisible())
     SetParentVisible(false);
   parent_ = parent;
   if (parent && parent->IsVisible())
     SetParentVisible(true);
 }
 
+FrameView* WebPluginContainerImpl::Parent() const {
+  if ((plugin_state_ == kAttached || plugin_state_ == kNotAttached) &&
+      element_->GetDocument().GetFrame())
+    DCHECK(ParentFrameView() == parent_);
+
+  return parent_;
+}
+
+FrameView* WebPluginContainerImpl::ParentFrameView() const {
+  if (plugin_state_ != kAttached)
+    return nullptr;
+
+  LocalFrame* frame = element_->GetDocument().GetFrame();
+  if (!frame)
+    return nullptr;
+
+  return frame->View();
+}
+
+void WebPluginContainerImpl::SetFrameOrPluginState(FrameOrPluginState state) {
+  VLOG(1) << "SetFrameOrPluginState " << this << " " << plugin_state_ << "->"
+          << state;
+  if (VLOG_IS_ON(2))
+    base::debug::StackTrace(10).Print();
+  switch (state) {
+    case kNotAttached:
+      DCHECK(plugin_state_ == kAttached);
+      break;
+    case kAttached:
+      DCHECK(plugin_state_ == kNotAttached);
+      break;
+    case kDeferred:
+      DCHECK(plugin_state_ == kNotAttached || plugin_state_ == kAttached ||
+             plugin_state_ == kDeferred);
+      break;
+    case kDisposed:
+      DCHECK(plugin_state_ == kNotAttached || plugin_state_ == kAttached ||
+             plugin_state_ == kDeferred || plugin_state_ == kDisposed);
+      break;
+    default:
+      NOTREACHED();
+  }
+  plugin_state_ = state;
+}
+
 void WebPluginContainerImpl::UpdateAllLifecyclePhases() {
   if (!web_plugin_)
     return;
 
   web_plugin_->UpdateAllLifecyclePhases();
 }
 
 void WebPluginContainerImpl::Paint(GraphicsContext& context,
                                    const CullRect& cull_rect) const {
-  if (!parent_)
+  DCHECK(plugin_state_ == kAttached);
+  FrameView* parent = ParentFrameView();
+  if (!parent)
     return;
 
   // Don't paint anything if the plugin doesn't intersect.
   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_,
                        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();
 
   // The plugin is positioned in the root frame's coordinates, so it needs to
   // be painted in them too.
-  IntPoint origin = parent_->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 = parent_->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_)
+  // TODO(joelhockey): Usually parent should only be called when attached,
+  // but this is also called in state kDisposed in Dispose.
+  // Also called in state kDeferred in plugins/tabindex.html
+  DCHECK(plugin_state_ == kAttached || plugin_state_ == kDeferred ||
+         plugin_state_ == kDisposed);
+  FrameView* parent = ParentFrameView();
+  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());
@@ skipping 241 matching lines @@
 void WebPluginContainerImpl::ScrollRect(const WebRect& rect) {
   InvalidateRect(rect);
 }
 
 void WebPluginContainerImpl::ScheduleAnimation() {
   if (auto* frame_view = element_->GetDocument().View())
     frame_view->ScheduleAnimation();
 }
 
 void WebPluginContainerImpl::ReportGeometry() {
+  DCHECK(plugin_state_ == kAttached);
+  FrameView* parent = ParentFrameView();
   // 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;
   CalculateGeometry(window_rect, clip_rect, unobscured_rect);
   web_plugin_->UpdateGeometry(window_rect, clip_rect, unobscured_rect,
                               self_visible_);
 }
 
 v8::Local<v8::Object> WebPluginContainerImpl::V8ObjectForElement() {
   LocalFrame* frame = element_->GetDocument().GetFrame();
@@ skipping 122 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_)
+      // TODO(joelhockey): Usually parent should only be called when in state
+      // kAttached, but this is called by TestPlugin::Initialize in state
+      // kNotAttached.
+      // Called in state kDisposed in plugins/re-request-touch-events-crash.html
+      DCHECK(plugin_state_ == kNotAttached || plugin_state_ == kAttached ||
+             plugin_state_ == kDisposed);
+      FrameView* parent = ParentFrameView();
+      if (parent)
         scrolling_coordinator->NotifyGeometryChanged();
     }
   }
 }
 
 WebPoint WebPluginContainerImpl::RootFrameToLocalPoint(
     const WebPoint& point_in_root_frame) {
-  if (!parent_)
+  DCHECK(plugin_state_ == kAttached);
+  FrameView* parent = ParentFrameView();
+  if (!parent)
     return point_in_root_frame;
-  WebPoint point_in_content = parent_->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) {
-  if (!parent_)
+  DCHECK(plugin_state_ == kAttached);
+  FrameView* parent = ParentFrameView();
+  if (!parent)
     return point_in_local;
   IntPoint absolute_point =
       RoundedIntPoint(element_->GetLayoutObject()->LocalToAbsolute(
           FloatPoint(point_in_local), kUseTransforms));
-  return parent_->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 48 matching lines @@
 
 bool WebPluginContainerImpl::WantsWheelEvents() {
   return wants_wheel_events_;
 }
 
 // Private methods -------------------------------------------------------------
 
 WebPluginContainerImpl::WebPluginContainerImpl(HTMLPlugInElement* element,
                                                WebPlugin* web_plugin)
     : ContextClient(element->GetDocument().GetFrame()),
+      parent_(nullptr),
+      plugin_state_(kNotAttached),
       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;
+  SetFrameOrPluginState(kDisposed);
 
   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) {
   // 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 = parent_;
+  DCHECK(plugin_state_ == kAttached);
+  FrameView* parent = ParentFrameView();
 
   // TODO(dtapuska): Move WebMouseEventBuilder into the anonymous namespace
   // in this class.
   WebMouseEventBuilder transformed_event(
-      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(
                          WebCoalescedInputEvent(transformed_event),
                          cursor_info) != WebInputEventResult::kNotHandled)
     event->SetDefaultHandled();
 
   // A windowless plugin can change the cursor in response to a mouse move
   // event.  We need to reflect the changed cursor in the frame view as the
   // mouse is moved in the boundaries of the windowless plugin.
-  Page* page = parent_view->GetFrame().GetPage();
+  Page* page = parent->GetFrame().GetPage();
   if (!page)
     return;
   page->GetChromeClient().SetCursorForPlugin(
-      cursor_info, &parent_view->GetFrame().LocalFrameRoot());
+      cursor_info, &parent->GetFrame().LocalFrameRoot());
 }
 
 void WebPluginContainerImpl::HandleDragEvent(MouseEvent* event) {
   DCHECK(event->IsDragEvent());
 
   WebDragStatus drag_status = kWebDragStatusUnknown;
   if (event->type() == EventTypeNames::dragenter)
     drag_status = kWebDragStatusEnter;
   else if (event->type() == EventTypeNames::dragleave)
     drag_status = kWebDragStatusLeave;
@@ skipping 16 matching lines @@
 
   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();
 
   // Translate the root frame position to content coordinates.
-  if (parent_) {
-    absolute_location = parent_->RootFrameToContents(absolute_location);
-  }
+  DCHECK(plugin_state_ == kAttached);
+  if (FrameView* parent = ParentFrameView())
+    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(WebCoalescedInputEvent(translated_event),
                                     cursor_info) !=
@@ skipping 124 matching lines @@
                                     cursor_info) !=
       WebInputEventResult::kNotHandled) {
     event->SetDefaultHandled();
     return;
   }
 
   // FIXME: Can a plugin change the cursor from a touch-event callback?
 }
 
 void WebPluginContainerImpl::SynthesizeMouseEventIfPossible(TouchEvent* event) {
+  DCHECK(plugin_state_ == kAttached);
+  FrameView* parent = ParentFrameView();
   WebMouseEventBuilder web_event(
-      parent_, LayoutItem(element_->GetLayoutObject()), *event);
+      parent, LayoutItem(element_->GetLayoutObject()), *event);
   if (web_event.GetType() == WebInputEvent::kUndefined)
     return;
 
   WebCursorInfo cursor_info;
   if (web_plugin_->HandleInputEvent(WebCoalescedInputEvent(web_event),
                                     cursor_info) !=
       WebInputEventResult::kNotHandled)
     event->SetDefaultHandled();
 }
 
 void WebPluginContainerImpl::FocusPlugin() {
-  LocalFrame& containing_frame = parent_->GetFrame();
-  if (Page* current_page = containing_frame.GetPage())
-    current_page->GetFocusController().SetFocusedElement(element_,
-                                                         &containing_frame);
-  else
-    containing_frame.GetDocument()->SetFocusedElement(
+  if (Page* current_page = GetFrame()->GetPage()) {
+    current_page->GetFocusController().SetFocusedElement(element_, GetFrame());
+  } else {
+    GetFrame()->GetDocument()->SetFocusedElement(
         element_, FocusParams(SelectionBehaviorOnFocus::kNone,
                               kWebFocusTypeNone, nullptr));
+  }
 }
 
 void WebPluginContainerImpl::IssuePaintInvalidations() {
   if (pending_invalidation_rect_.IsEmpty())
     return;
 
   LayoutBox* layout_object = ToLayoutBox(element_->GetLayoutObject());
   if (!layout_object)
     return;
 
@@ skipping 75 matching lines @@
            .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);
   }
 }
 
 }  // namespace blink