Rename platform/Widget to platform/FrameViewBase in core.

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 20 matching lines @@
 #include "core/frame/LocalFrameClient.h"
 #include "core/layout/LayoutPart.h"
 #include "core/layout/api/LayoutPartItem.h"
 #include "core/loader/FrameLoadRequest.h"
 #include "core/loader/FrameLoader.h"
 #include "core/plugins/PluginView.h"
 #include "platform/weborigin/SecurityOrigin.h"
 
 namespace blink {
 
-typedef HeapHashMap<Member<Widget>, Member<FrameView>> WidgetToParentMap;
-static WidgetToParentMap& widgetNewParentMap() {
-  DEFINE_STATIC_LOCAL(WidgetToParentMap, map, (new WidgetToParentMap));
+typedef HeapHashMap<Member<FrameViewBase>, Member<FrameView>>
+    FrameViewBaseToParentMap;
+static FrameViewBaseToParentMap& widgetNewParentMap() {
+  DEFINE_STATIC_LOCAL(FrameViewBaseToParentMap, map,
+                      (new FrameViewBaseToParentMap));
   return map;
 }
 
-using WidgetSet = HeapHashSet<Member<Widget>>;
-static WidgetSet& widgetsPendingTemporaryRemovalFromParent() {
-  // Widgets in this set will not leak because it will be cleared in
+using FrameViewBaseSet = HeapHashSet<Member<FrameViewBase>>;
+static FrameViewBaseSet& widgetsPendingTemporaryRemovalFromParent() {
+  // FrameViewBases in this set will not leak because it will be cleared in
   // HTMLFrameOwnerElement::UpdateSuspendScope::performDeferredWidgetTreeOperations.
-  DEFINE_STATIC_LOCAL(WidgetSet, set, (new WidgetSet));
+  DEFINE_STATIC_LOCAL(FrameViewBaseSet, set, (new FrameViewBaseSet));
   return set;
 }
 
-static WidgetSet& widgetsPendingDispose() {
-  DEFINE_STATIC_LOCAL(WidgetSet, set, (new WidgetSet));
+static FrameViewBaseSet& widgetsPendingDispose() {
+  DEFINE_STATIC_LOCAL(FrameViewBaseSet, set, (new FrameViewBaseSet));
   return set;
 }
 
 SubframeLoadingDisabler::SubtreeRootSet&
 SubframeLoadingDisabler::disabledSubtreeRoots() {
   DEFINE_STATIC_LOCAL(SubtreeRootSet, nodes, ());
   return nodes;
 }
 
 static unsigned s_updateSuspendCount = 0;
 
 HTMLFrameOwnerElement::UpdateSuspendScope::UpdateSuspendScope() {
   ++s_updateSuspendCount;
 }
 
 void HTMLFrameOwnerElement::UpdateSuspendScope::
     performDeferredWidgetTreeOperations() {
-  WidgetToParentMap map;
+  FrameViewBaseToParentMap map;
   widgetNewParentMap().swap(map);
-  for (const auto& widget : map) {
-    Widget* child = widget.key.get();
+  for (const auto& frameViewBase : map) {
+    FrameViewBase* child = frameViewBase.key.get();
     FrameView* currentParent = toFrameView(child->parent());
-    FrameView* newParent = widget.value;
+    FrameView* newParent = frameViewBase.value;
     if (newParent != currentParent) {
       if (currentParent)
         currentParent->removeChild(child);
       if (newParent)
         newParent->addChild(child);
       if (currentParent && !newParent)
         child->dispose();
     }
   }
 
   {
-    WidgetSet set;
+    FrameViewBaseSet set;
     widgetsPendingTemporaryRemovalFromParent().swap(set);
-    for (const auto& widget : set) {
-      FrameView* currentParent = toFrameView(widget->parent());
+    for (const auto& frameViewBase : set) {
+      FrameView* currentParent = toFrameView(frameViewBase->parent());
       if (currentParent)
-        currentParent->removeChild(widget.get());
+        currentParent->removeChild(frameViewBase.get());
     }
   }
 
   {
-    WidgetSet set;
+    FrameViewBaseSet set;
     widgetsPendingDispose().swap(set);
-    for (const auto& widget : set) {
-      widget->dispose();
+    for (const auto& frameViewBase : set) {
+      frameViewBase->dispose();
     }
   }
 }
 
 HTMLFrameOwnerElement::UpdateSuspendScope::~UpdateSuspendScope() {
   DCHECK_GT(s_updateSuspendCount, 0u);
   if (s_updateSuspendCount == 1)
     performDeferredWidgetTreeOperations();
   --s_updateSuspendCount;
 }
 
 // Unlike moveWidgetToParentSoon, this will not call dispose the Widget.
-void temporarilyRemoveWidgetFromParentSoon(Widget* widget) {
+void temporarilyRemoveWidgetFromParentSoon(FrameViewBase* frameViewBase) {
   if (s_updateSuspendCount) {
-    widgetsPendingTemporaryRemovalFromParent().insert(widget);
+    widgetsPendingTemporaryRemovalFromParent().insert(frameViewBase);
   } else {
-    if (toFrameView(widget->parent()))
-      toFrameView(widget->parent())->removeChild(widget);
+    if (toFrameView(frameViewBase->parent()))
+      toFrameView(frameViewBase->parent())->removeChild(frameViewBase);
   }
 }
 
-void moveWidgetToParentSoon(Widget* child, FrameView* parent) {
+void moveWidgetToParentSoon(FrameViewBase* child, FrameView* parent) {
   if (!s_updateSuspendCount) {
     if (parent) {
       parent->addChild(child);
     } else if (toFrameView(child->parent())) {
       toFrameView(child->parent())->removeChild(child);
       child->dispose();
     }
     return;
   }
   widgetNewParentMap().set(child, parent);
@@ skipping 69 matching lines @@
   // the subframe hasn't been created yet.
   if (contentFrame())
     document().frame()->loader().client()->didChangeSandboxFlags(contentFrame(),
                                                                  flags);
 }
 
 bool HTMLFrameOwnerElement::isKeyboardFocusable() const {
   return m_contentFrame && HTMLElement::isKeyboardFocusable();
 }
 
-void HTMLFrameOwnerElement::disposeWidgetSoon(Widget* widget) {
+void HTMLFrameOwnerElement::disposeWidgetSoon(FrameViewBase* frameViewBase) {
   if (s_updateSuspendCount) {
-    widgetsPendingDispose().insert(widget);
+    widgetsPendingDispose().insert(frameViewBase);
     return;
   }
-  widget->dispose();
+  frameViewBase->dispose();
 }
 
 void HTMLFrameOwnerElement::dispatchLoad() {
   dispatchScopedEvent(Event::create(EventTypeNames::load));
 }
 
 const WebVector<mojom::blink::PermissionName>&
 HTMLFrameOwnerElement::delegatedPermissions() const {
   DEFINE_STATIC_LOCAL(WebVector<mojom::blink::PermissionName>, permissions, ());
   return permissions;
 }
 
 const WebVector<WebFeaturePolicyFeature>&
 HTMLFrameOwnerElement::allowedFeatures() const {
   DEFINE_STATIC_LOCAL(WebVector<WebFeaturePolicyFeature>, features, ());
   return features;
 }
 
 Document* HTMLFrameOwnerElement::getSVGDocument(
     ExceptionState& exceptionState) const {
   Document* doc = contentDocument();
   if (doc && doc->isSVGDocument())
     return doc;
   return nullptr;
 }
 
-void HTMLFrameOwnerElement::setWidget(Widget* widget) {
-  if (widget == m_widget)
+void HTMLFrameOwnerElement::setWidget(FrameViewBase* frameViewBase) {
+  if (frameViewBase == m_widget)
     return;
 
   if (m_widget) {
     if (m_widget->parent())
       moveWidgetToParentSoon(m_widget.get(), 0);
     m_widget = nullptr;
   }
 
-  m_widget = widget;
+  m_widget = frameViewBase;
 
   LayoutPart* layoutPart = toLayoutPart(layoutObject());
   LayoutPartItem layoutPartItem = LayoutPartItem(layoutPart);
   if (layoutPartItem.isNull())
     return;
 
   if (m_widget) {
     layoutPartItem.updateOnWidgetChange();
 
     DCHECK_EQ(document().view(), layoutPartItem.frameView());
     DCHECK(layoutPartItem.frameView());
     moveWidgetToParentSoon(m_widget.get(), layoutPartItem.frameView());
   }
 
   if (AXObjectCache* cache = document().existingAXObjectCache())
     cache->childrenChanged(layoutPart);
 }
 
-Widget* HTMLFrameOwnerElement::releaseWidget() {
+FrameViewBase* HTMLFrameOwnerElement::releaseWidget() {
   if (!m_widget)
     return nullptr;
   if (m_widget->parent())
     temporarilyRemoveWidgetFromParentSoon(m_widget.get());
   LayoutPart* layoutPart = toLayoutPart(layoutObject());
   if (layoutPart) {
     if (AXObjectCache* cache = document().existingAXObjectCache())
       cache->childrenChanged(layoutPart);
   }
   return m_widget.release();
 }
 
-Widget* HTMLFrameOwnerElement::ownedWidget() const {
+FrameViewBase* HTMLFrameOwnerElement::ownedWidget() const {
   return m_widget.get();
 }
 
 bool HTMLFrameOwnerElement::loadOrRedirectSubframe(
     const KURL& url,
     const AtomicString& frameName,
     bool replaceCurrentItem) {
   LocalFrame* parentFrame = document().frame();
   if (contentFrame()) {
     contentFrame()->navigate(document(), url, replaceCurrentItem,
@@ skipping 27 matching lines @@
 }
 
 DEFINE_TRACE(HTMLFrameOwnerElement) {
   visitor->trace(m_contentFrame);
   visitor->trace(m_widget);
   HTMLElement::trace(visitor);
   FrameOwner::trace(visitor);
 }
 
 }  // namespace blink