Rename platform/Widget to platform/FrameViewBase in core.

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

 /**
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Stefan Schimanski (1Stein@gmx.de)
  * Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.
  *
  * 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.
@@ skipping 28 matching lines @@
 #include "core/html/PluginDocument.h"
 #include "core/input/EventHandler.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/layout/LayoutImage.h"
 #include "core/layout/LayoutPart.h"
 #include "core/layout/api/LayoutEmbeddedItem.h"
 #include "core/loader/MixedContentChecker.h"
 #include "core/page/Page.h"
 #include "core/page/scrolling/ScrollingCoordinator.h"
 #include "core/plugins/PluginView.h"
+#include "platform/FrameViewBase.h"
 #include "platform/Histogram.h"
-#include "platform/Widget.h"
 #include "platform/network/ResourceRequest.h"
 #include "platform/network/mime/MIMETypeFromURL.h"
 #include "platform/network/mime/MIMETypeRegistry.h"
 #include "platform/plugins/PluginData.h"
 #include "public/platform/WebURLRequest.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
@@ skipping 10 matching lines @@
 }  // anonymous namespace
 
 HTMLPlugInElement::HTMLPlugInElement(
     const QualifiedName& tagName,
     Document& doc,
     bool createdByParser,
     PreferPlugInsForImagesOption preferPlugInsForImagesOption)
     : HTMLFrameOwnerElement(tagName, doc),
       m_isDelayingLoadEvent(false),
       // m_needsWidgetUpdate(!createdByParser) allows HTMLObjectElement to delay
-      // widget updates until after all children are parsed. For
+      // FrameViewBase updates until after all children are parsed. For
       // HTMLEmbedElement this delay is unnecessary, but it is simpler to make
       // both classes share the same codepath in this class.
       m_needsWidgetUpdate(!createdByParser),
       m_shouldPreferPlugInsForImages(preferPlugInsForImagesOption ==
                                      ShouldPreferPlugInsForImages) {}
 
 HTMLPlugInElement::~HTMLPlugInElement() {
   DCHECK(!m_pluginWrapper);  // cleared in detachLayoutTree()
   DCHECK(!m_isDelayingLoadEvent);
 }
 
 DEFINE_TRACE(HTMLPlugInElement) {
   visitor->trace(m_imageLoader);
   visitor->trace(m_persistedPluginWidget);
   HTMLFrameOwnerElement::trace(visitor);
 }
 
-void HTMLPlugInElement::setPersistedPluginWidget(Widget* widget) {
-  if (m_persistedPluginWidget == widget)
+void HTMLPlugInElement::setPersistedPluginWidget(FrameViewBase* frameViewBase) {
+  if (m_persistedPluginWidget == frameViewBase)
     return;
   if (m_persistedPluginWidget) {
     if (m_persistedPluginWidget->isPluginView()) {
       m_persistedPluginWidget->hide();
       disposeWidgetSoon(m_persistedPluginWidget.release());
     } else {
       DCHECK(m_persistedPluginWidget->isFrameView() ||
              m_persistedPluginWidget->isRemoteFrameView());
     }
   }
-  m_persistedPluginWidget = widget;
+  m_persistedPluginWidget = frameViewBase;
 }
 
 bool HTMLPlugInElement::requestObjectInternal(
     const String& url,
     const String& mimeType,
     const Vector<String>& paramNames,
     const Vector<String>& paramValues) {
   if (url.isEmpty() && mimeType.isEmpty())
     return false;
 
   if (protocolIsJavaScript(url))
     return false;
 
   KURL completedURL = url.isEmpty() ? KURL() : document().completeURL(url);
   if (!allowedToLoadObject(completedURL, mimeType))
     return false;
 
   bool useFallback;
   if (!shouldUsePlugin(completedURL, mimeType, hasFallbackContent(),
                        useFallback)) {
     // If the plugin element already contains a subframe,
     // loadOrRedirectSubframe will re-use it. Otherwise, it will create a
-    // new frame and set it as the LayoutPart's widget, causing what was
-    // previously in the widget to be torn down.
+    // new frame and set it as the LayoutPart's FrameViewBase, causing what was
+    // previously in the FrameViewBase to be torn down.
     return loadOrRedirectSubframe(completedURL, getNameAttribute(), true);
   }
 
   return loadPlugin(completedURL, mimeType, paramNames, paramValues,
                     useFallback, true);
 }
 
 bool HTMLPlugInElement::canProcessDrag() const {
   return pluginWidget() && pluginWidget()->isPluginView() &&
          toPluginView(pluginWidget())->canProcessDrag();
 }
 
 bool HTMLPlugInElement::canStartSelection() const {
   return useFallbackContent() && Node::canStartSelection();
 }
 
 bool HTMLPlugInElement::willRespondToMouseClickEvents() {
   if (isDisabledFormControl())
     return false;
   LayoutObject* r = layoutObject();
   return r && (r->isEmbeddedObject() || r->isLayoutPart());
 }
 
 void HTMLPlugInElement::removeAllEventListeners() {
   HTMLFrameOwnerElement::removeAllEventListeners();
   if (LayoutPart* layoutObject = existingLayoutPart()) {
-    if (Widget* widget = layoutObject->widget())
-      widget->eventListenersRemoved();
+    if (FrameViewBase* frameViewBase = layoutObject->widget())
+      frameViewBase->eventListenersRemoved();
   }
 }
 
 void HTMLPlugInElement::didMoveToNewDocument(Document& oldDocument) {
   if (m_imageLoader)
     m_imageLoader->elementDidMoveToNewDocument();
   HTMLFrameOwnerElement::didMoveToNewDocument(oldDocument);
 }
 
 void HTMLPlugInElement::attachLayoutTree(const AttachContext& context) {
@@ skipping 71 matching lines @@
   Vector<String> paramValues;
 
   paramNames.push_back("type");
   paramValues.push_back(m_serviceType);
 
   bool useFallback = false;
   loadPlugin(url, m_serviceType, paramNames, paramValues, useFallback, false);
 }
 
 bool HTMLPlugInElement::shouldAccelerate() const {
-  if (Widget* widget = ownedWidget())
-    return widget->isPluginView() && toPluginView(widget)->platformLayer();
+  if (FrameViewBase* frameViewBase = ownedWidget()) {
+    return frameViewBase->isPluginView() &&
+           toPluginView(frameViewBase)->platformLayer();
+  }
   return false;
 }
 
 void HTMLPlugInElement::detachLayoutTree(const AttachContext& context) {
-  // Update the widget the next time we attach (detaching destroys the plugin).
+  // Update the FrameViewBase the next time we attach (detaching destroys the
+  // plugin).
   // FIXME: None of this "needsWidgetUpdate" related code looks right.
   if (layoutObject() && !useFallbackContent())
     setNeedsWidgetUpdate(true);
   if (m_isDelayingLoadEvent) {
     m_isDelayingLoadEvent = false;
     document().decrementLoadEventDelayCount();
   }
 
-  // Only try to persist a plugin widget we actually own.
-  Widget* plugin = ownedWidget();
+  // Only try to persist a plugin FrameViewBase we actually own.
+  FrameViewBase* plugin = ownedWidget();
   if (plugin && context.performingReattach) {
     setPersistedPluginWidget(releaseWidget());
   } else {
-    // Clear the widget; will trigger disposal of it with Oilpan.
+    // Clear the FrameViewBase; will trigger disposal of it with Oilpan.
     setWidget(nullptr);
   }
 
   resetInstance();
 
   HTMLFrameOwnerElement::detachLayoutTree(context);
 }
 
 LayoutObject* HTMLPlugInElement::createLayoutObject(
     const ComputedStyle& style) {
@@ skipping 29 matching lines @@
 
 SharedPersistent<v8::Object>* HTMLPlugInElement::pluginWrapper() {
   LocalFrame* frame = document().frame();
   if (!frame)
     return nullptr;
 
   // If the host dynamically turns off JavaScript (or Java) we will still
   // return the cached allocated Bindings::Instance. Not supporting this
   // edge-case is OK.
   if (!m_pluginWrapper) {
-    Widget* plugin;
+    FrameViewBase* plugin;
 
     if (m_persistedPluginWidget)
       plugin = m_persistedPluginWidget.get();
     else
       plugin = pluginWidget();
 
     if (plugin)
       m_pluginWrapper = frame->script().createPluginWrapper(plugin);
   }
   return m_pluginWrapper.get();
 }
 
-Widget* HTMLPlugInElement::pluginWidget() const {
+FrameViewBase* HTMLPlugInElement::pluginWidget() const {
   if (LayoutPart* layoutPart = layoutPartForJSBindings())
     return layoutPart->widget();
   return nullptr;
 }
 
 bool HTMLPlugInElement::isPresentationAttribute(
     const QualifiedName& name) const {
   if (name == widthAttr || name == heightAttr || name == vspaceAttr ||
       name == hspaceAttr || name == alignAttr)
     return true;
@@ skipping 34 matching lines @@
   // code in EventHandler; these code paths should be united.
 
   LayoutObject* r = layoutObject();
   if (!r || !r->isLayoutPart())
     return;
   if (r->isEmbeddedObject()) {
     if (LayoutEmbeddedItem(toLayoutEmbeddedObject(r))
             .showsUnavailablePluginIndicator())
       return;
   }
-  Widget* widget = toLayoutPart(r)->widget();
-  if (!widget)
+  FrameViewBase* frameViewBase = toLayoutPart(r)->widget();
+  if (!frameViewBase)
     return;
-  widget->handleEvent(event);
+  frameViewBase->handleEvent(event);
   if (event->defaultHandled())
     return;
   HTMLFrameOwnerElement::defaultEventHandler(event);
 }
 
 LayoutPart* HTMLPlugInElement::layoutPartForJSBindings() const {
   // Needs to load the plugin immediatedly because this function is called
   // when JavaScript code accesses the plugin.
   // FIXME: Check if dispatching events here is safe.
   document().updateStyleAndLayoutIgnorePendingStylesheets(
@@ skipping 114 matching lines @@
   m_loadedUrl = url;
 
   if (m_persistedPluginWidget) {
     setWidget(m_persistedPluginWidget.release());
   } else {
     bool loadManually =
         document().isPluginDocument() && !document().containsPlugins();
     LocalFrameClient::DetachedPluginPolicy policy =
         requireLayoutObject ? LocalFrameClient::FailOnDetachedPlugin
                             : LocalFrameClient::AllowDetachedPlugin;
-    Widget* widget = frame->loader().client()->createPlugin(
+    FrameViewBase* frameViewBase = frame->loader().client()->createPlugin(
         this, url, paramNames, paramValues, mimeType, loadManually, policy);
-    if (!widget) {
+    if (!frameViewBase) {
       if (!layoutItem.isNull() &&
           !layoutItem.showsUnavailablePluginIndicator()) {
         m_pluginIsAvailable = false;
         layoutItem.setPluginAvailability(LayoutEmbeddedObject::PluginMissing);
       }
       return false;
     }
 
     if (!layoutItem.isNull())
-      setWidget(widget);
+      setWidget(frameViewBase);
     else
-      setPersistedPluginWidget(widget);
+      setPersistedPluginWidget(frameViewBase);
   }
 
   document().setContainsPlugins();
   // TODO(esprehn): WebPluginContainerImpl::setWebLayer also schedules a
   // compositing update, do we need both?
   setNeedsCompositingUpdate();
   // Make sure any input event handlers introduced by the plugin are taken into
   // account.
   if (Page* page = document().frame()->page()) {
     if (ScrollingCoordinator* scrollingCoordinator =
@@ skipping 90 matching lines @@
 
 void HTMLPlugInElement::lazyReattachIfNeeded() {
   if (!useFallbackContent() && needsWidgetUpdate() && layoutObject() &&
       !isImageType()) {
     lazyReattachIfAttached();
     setPersistedPluginWidget(nullptr);
   }
 }
 
 }  // namespace blink