Remove FrameViewBase as base class of RemoteFrameView.

third_party/WebKit/Source/core/html/HTMLFrameOwnerElement.cpp

 /*
  * Copyright (C) 2006, 2007, 2009 Apple Inc. 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
@@ skipping 10 matching lines @@
 #include "core/html/HTMLFrameOwnerElement.h"
 
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "core/dom/AXObjectCache.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/events/Event.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/LocalFrameClient.h"
+#include "core/frame/RemoteFrameView.h"
 #include "core/layout/LayoutPart.h"
 #include "core/layout/api/LayoutPartItem.h"
 #include "core/loader/FrameLoadRequest.h"
 #include "core/loader/FrameLoader.h"
 #include "core/page/Page.h"
 #include "core/plugins/PluginView.h"
 #include "platform/heap/HeapAllocator.h"
 #include "platform/weborigin/SecurityOrigin.h"
 
 namespace blink {
 
-typedef HeapHashMap<Member<FrameViewBase>, Member<FrameView>>
-    FrameViewBaseToParentMap;
-static FrameViewBaseToParentMap& WidgetNewParentMap() {
-  DEFINE_STATIC_LOCAL(FrameViewBaseToParentMap, map,
-                      (new FrameViewBaseToParentMap));
+using FrameOrPluginToParentMap =
+    HeapHashMap<Member<FrameOrPlugin>, Member<FrameView>>;
+
+static FrameOrPluginToParentMap& FrameOrPluginNewParentMap() {
+  DEFINE_STATIC_LOCAL(FrameOrPluginToParentMap, map,
+                      (new FrameOrPluginToParentMap));
   return map;
 }
 
-using FrameViewBaseSet = HeapHashSet<Member<FrameViewBase>>;
-static FrameViewBaseSet& WidgetsPendingTemporaryRemovalFromParent() {
-  // FrameViewBases in this set will not leak because it will be cleared in
+using FrameOrPluginSet = HeapHashSet<Member<FrameOrPlugin>>;
+static FrameOrPluginSet& FrameOrPluginsPendingTemporaryRemovalFromParent() {
+  // FrameOrPlugins in this set will not leak because it will be cleared in
   // HTMLFrameOwnerElement::UpdateSuspendScope::performDeferredWidgetTreeOperations.
-  DEFINE_STATIC_LOCAL(FrameViewBaseSet, set, (new FrameViewBaseSet));
+  DEFINE_STATIC_LOCAL(FrameOrPluginSet, set, (new FrameOrPluginSet));
   return set;
 }
 
-using FrameOrPluginList = HeapVector<Member<FrameOrPlugin>>;
-static FrameOrPluginList& FrameOrPluginsPendingDispose() {
-  DEFINE_STATIC_LOCAL(FrameOrPluginList, list, (new FrameOrPluginList));
-  return list;
+static FrameOrPluginSet& FrameOrPluginsPendingDispose() {
+  DEFINE_STATIC_LOCAL(FrameOrPluginSet, set, (new FrameOrPluginSet));
+  return set;
 }
 
 SubframeLoadingDisabler::SubtreeRootSet&
 SubframeLoadingDisabler::DisabledSubtreeRoots() {
   DEFINE_STATIC_LOCAL(SubtreeRootSet, nodes, ());
   return nodes;
 }
 
 static unsigned g_update_suspend_count = 0;
 
 HTMLFrameOwnerElement::UpdateSuspendScope::UpdateSuspendScope() {
   ++g_update_suspend_count;
 }
 
 void HTMLFrameOwnerElement::UpdateSuspendScope::
     PerformDeferredWidgetTreeOperations() {
-  FrameViewBaseToParentMap map;
-  WidgetNewParentMap().swap(map);
-  for (const auto& frame_view_base : map) {
-    FrameViewBase* child = frame_view_base.key.Get();
-    FrameView* current_parent = ToFrameView(child->Parent());
-    FrameView* new_parent = frame_view_base.value;
+  FrameOrPluginToParentMap map;
+  FrameOrPluginNewParentMap().swap(map);
+  for (const auto& entry : map) {
+    FrameOrPlugin* child = entry.key;
+    FrameView* current_parent = child->Parent();
+    FrameView* new_parent = entry.value;
     if (new_parent != current_parent) {
       if (current_parent)
         current_parent->RemoveChild(child);
       if (new_parent)
         new_parent->AddChild(child);
       if (current_parent && !new_parent)
         child->Dispose();
     }
   }
 
-  {
-    FrameViewBaseSet set;
-    WidgetsPendingTemporaryRemovalFromParent().swap(set);
-    for (const auto& frame_view_base : set) {
-      FrameView* current_parent = ToFrameView(frame_view_base->Parent());
-      if (current_parent)
-        current_parent->RemoveChild(frame_view_base.Get());
-    }
+  FrameOrPluginSet remove_set;
+  FrameOrPluginsPendingTemporaryRemovalFromParent().swap(remove_set);
+  for (const auto& child : remove_set) {
+    if (child->Parent())
+      child->Parent()->RemoveChild(child);
   }
 
-  {
-    FrameOrPluginList list;
-    FrameOrPluginsPendingDispose().swap(list);
-    for (const auto& frame_or_plugin : list) {
-      frame_or_plugin->Dispose();
-    }
+  FrameOrPluginSet dispose_set;
+  FrameOrPluginsPendingDispose().swap(dispose_set);
+  for (const auto& frame_or_plugin : dispose_set) {
+    frame_or_plugin->Dispose();
   }
 }
 
 HTMLFrameOwnerElement::UpdateSuspendScope::~UpdateSuspendScope() {
   DCHECK_GT(g_update_suspend_count, 0u);
   if (g_update_suspend_count == 1)
     PerformDeferredWidgetTreeOperations();
   --g_update_suspend_count;
 }
 
-// Unlike moveWidgetToParentSoon, this will not call dispose.
-void TemporarilyRemoveWidgetFromParentSoon(FrameViewBase* frame_view_base) {
+// Unlike MoveFrameOrPluginToParentSoon, this will not call dispose.
+void TemporarilyRemoveFrameOrPluginFromParentSoon(FrameOrPlugin* child) {
   if (g_update_suspend_count) {
-    WidgetsPendingTemporaryRemovalFromParent().insert(frame_view_base);
+    FrameOrPluginsPendingTemporaryRemovalFromParent().insert(child);
   } else {
-    if (ToFrameView(frame_view_base->Parent()))
-      ToFrameView(frame_view_base->Parent())->RemoveChild(frame_view_base);
+    if (child->Parent())
+      child->Parent()->RemoveChild(child);
   }
 }
 
-void MoveWidgetToParentSoon(FrameViewBase* child, FrameView* parent) {
+void MoveFrameOrPluginToParentSoon(FrameOrPlugin* child, FrameView* parent) {
   if (!g_update_suspend_count) {
     if (parent) {
       parent->AddChild(child);
-    } else if (ToFrameView(child->Parent())) {
-      ToFrameView(child->Parent())->RemoveChild(child);
+    } else if (child->Parent()) {
+      child->Parent()->RemoveChild(child);
       child->Dispose();
     }
     return;
   }
-  WidgetNewParentMap().Set(child, parent);
+  FrameOrPluginNewParentMap().Set(child, parent);
 }
 
 HTMLFrameOwnerElement::HTMLFrameOwnerElement(const QualifiedName& tag_name,
                                              Document& document)
     : HTMLElement(tag_name, document),
       content_frame_(nullptr),
       widget_(nullptr),
       sandbox_flags_(kSandboxNone) {}
 
 LayoutPart* HTMLFrameOwnerElement::GetLayoutPart() const {
@@ skipping 69 matching lines @@
   }
 }
 
 bool HTMLFrameOwnerElement::IsKeyboardFocusable() const {
   return content_frame_ && HTMLElement::IsKeyboardFocusable();
 }
 
 void HTMLFrameOwnerElement::DisposeFrameOrPluginSoon(
     FrameOrPlugin* frame_or_plugin) {
   if (g_update_suspend_count) {
-    FrameOrPluginsPendingDispose().push_back(frame_or_plugin);
-    return;
+    FrameOrPluginsPendingDispose().insert(frame_or_plugin);
+  } else {
+    frame_or_plugin->Dispose();
   }
-  frame_or_plugin->Dispose();
 }
 
 void HTMLFrameOwnerElement::UpdateContainerPolicy() {
   container_policy_ = GetContainerPolicyFromAllowedFeatures(
       AllowedFeatures(), AllowFullscreen(), AllowPaymentRequest(),
       GetOriginForFeaturePolicy());
   // Don't notify about updates if ContentFrame() is null, for example when
   // the subframe hasn't been created yet.
   if (ContentFrame()) {
     GetDocument().GetFrame()->Loader().Client()->DidChangeFramePolicy(
@@ skipping 25 matching lines @@
 }
 
 Document* HTMLFrameOwnerElement::getSVGDocument(
     ExceptionState& exception_state) const {
   Document* doc = contentDocument();
   if (doc && doc->IsSVGDocument())
     return doc;
   return nullptr;
 }
 
-void HTMLFrameOwnerElement::SetWidget(FrameViewBase* frame_view_base) {
-  if (frame_view_base == widget_)
+void HTMLFrameOwnerElement::SetWidget(FrameOrPlugin* frame_or_plugin) {
+  if (frame_or_plugin == widget_)
     return;
 
   Document* doc = contentDocument();
   if (doc && doc->GetFrame()) {
-    bool will_be_display_none = !frame_view_base;
+    bool will_be_display_none = !frame_or_plugin;
     if (IsDisplayNone() != will_be_display_none) {
       doc->WillChangeFrameOwnerProperties(
           MarginWidth(), MarginHeight(), ScrollingMode(), will_be_display_none);
     }
   }
 
   if (widget_) {
     if (widget_->Parent())
-      MoveWidgetToParentSoon(widget_.Get(), 0);
-    widget_ = nullptr;
+      MoveFrameOrPluginToParentSoon(widget_, nullptr);
   }
 
-  widget_ = frame_view_base;
+  widget_ = frame_or_plugin;
   FrameOwnerPropertiesChanged();
 
   LayoutPart* layout_part = ToLayoutPart(GetLayoutObject());
   LayoutPartItem layout_part_item = LayoutPartItem(layout_part);
   if (layout_part_item.IsNull())
     return;
 
   if (widget_) {
     layout_part_item.UpdateOnWidgetChange();
 
     DCHECK_EQ(GetDocument().View(), layout_part_item.GetFrameView());
     DCHECK(layout_part_item.GetFrameView());
-    MoveWidgetToParentSoon(widget_.Get(), layout_part_item.GetFrameView());
+    MoveFrameOrPluginToParentSoon(widget_, layout_part_item.GetFrameView());
   }
 
   if (AXObjectCache* cache = GetDocument().ExistingAXObjectCache())
     cache->ChildrenChanged(layout_part);
 }
 
-FrameViewBase* HTMLFrameOwnerElement::ReleaseWidget() {
+FrameOrPlugin* HTMLFrameOwnerElement::ReleaseWidget() {
   if (!widget_)
     return nullptr;
   if (widget_->Parent())
-    TemporarilyRemoveWidgetFromParentSoon(widget_.Get());
+    TemporarilyRemoveFrameOrPluginFromParentSoon(widget_);
   LayoutPart* layout_part = ToLayoutPart(GetLayoutObject());
   if (layout_part) {
     if (AXObjectCache* cache = GetDocument().ExistingAXObjectCache())
       cache->ChildrenChanged(layout_part);
   }
   return widget_.Release();
 }
 
-FrameViewBase* HTMLFrameOwnerElement::OwnedWidget() const {
-  return widget_.Get();
-}
-
 bool HTMLFrameOwnerElement::LoadOrRedirectSubframe(
     const KURL& url,
     const AtomicString& frame_name,
     bool replace_current_item) {
   UpdateContainerPolicy();
 
   LocalFrame* parent_frame = GetDocument().GetFrame();
   if (ContentFrame()) {
     ContentFrame()->Navigate(GetDocument(), url, replace_current_item,
                              UserGestureStatus::kNone);
@@ skipping 26 matching lines @@
 }
 
 DEFINE_TRACE(HTMLFrameOwnerElement) {
   visitor->Trace(content_frame_);
   visitor->Trace(widget_);
   HTMLElement::Trace(visitor);
   FrameOwner::Trace(visitor);
 }
 
 }  // namespace blink