Title: [263017] trunk
Revision
263017
Author
[email protected]
Date
2020-06-14 19:07:08 -0700 (Sun, 14 Jun 2020)

Log Message

[WPT] html/webappapis/system-state-and-capabilities/the-navigator-object/navigator-pluginarray.html fails due to lack of caching of Plugin objects
https://bugs.webkit.org/show_bug.cgi?id=213185

Reviewed by Darin Adler.

LayoutTests/imported/w3c:

* web-platform-tests/html/webappapis/system-state-and-capabilities/the-navigator-object/navigator-pluginarray-expected.txt:
Update results now that this test passes.

Source/WebCore:

Tests:
- Updates results for web-platform-tests/html/webappapis/system-state-and-capabilities/the-navigator-object/navigator-pluginarray.html
  which now passes.
- Splits up http/tests/plugins/plugin-_javascript_-access.html, adding
  http/tests/plugins/plugin-_javascript_-access-allow-all-plugins.html
  which tests the internals.setShowAllPlugins(true) case. This was
  required now that the plugin and mimetype arrays are immutable after
  creation.

Overhaul web exposed plugin APIs:
- All DOMPlugin and DOMMimeTypes are now created together (along with the DOMPluginArray and
  DOMMimeTypeArray) on first access of either navigator.plugins or navigator.mimeTypes.
- DOMPlugins are created and stored in the DOMPluginArray (fixing the initial lack of caching issue)
- DOMMimeTypes are created and stored in the DOMMimeTypeArray.
- DOMPlugins hold a strong reference to their associated DOMMimeType. The DOMMimeType has
  a weak reference back to the DOMPlugin. This means for a single executation context, we only
  ever create one DOMPlugin / DOMMimeType for each underlying plugin / mimetype.
- Update GC so that DOMPlugin and DOMMimeType (in addition to DOMPluginArray and DOMMimeTypeArray
  which were already doing this) use navigator reachability for their lifetime. This is almost
  correct, except if we ever implement DOMPluginArray.refresh(false) to match the spec, in which
  case you could end up with some DOMPlugins and DOMMimeTypes that are marked as reachable when
  they really are not, but only plugins that were removed. This seems so unlikely to matter that
  implementing a more strict reachability function seems like the wrong way to go.

* CMakeLists.txt:
* DerivedSources-input.xcfilelist:
* DerivedSources.make:
* WebCore.xcodeproj/project.pbxproj:
Add NavigatorPlugins.idl

* loader/SubframeLoader.cpp:
(WebCore::findPluginMIMETypeFromURL):
(WebCore::logPluginRequest):
Simplify and cleanup code making use of the new webVisibleMimeTypes() rather than the
clunky getWebVisibleMimesAndPluginIndices().

* page/Navigator.cpp:
* page/Navigator.h:
(WebCore::Navigator::initializePluginAndMIMETypeArrays):
(WebCore::Navigator::plugins):
(WebCore::Navigator::mimeTypes):
Fully initialize Navigator.plugins/mimeTypes on first access of either, following
the specified behavior that they should not change after initial access for a script
execution context. This also ensures we always return the same wrappers for these
objects on multiple accesses, something the spec mandates but we failed to do prior.
In addition, we now correctly sort the plugins by name and mimeTypes by type, also as
specified.

* page/Navigator.idl:
* page/NavigatorPlugins.idl: Added.
Split NavigatorPlugins out of Navigator.idl as specified. No functional change but
makes things nicer when we match the spec closer.

* plugins/DOMMimeType.cpp:
(WebCore::DOMMimeType::DOMMimeType):
(WebCore::DOMMimeType::suffixes const):
(WebCore::DOMMimeType::enabledPlugin const):
* plugins/DOMMimeType.h:
(WebCore::DOMMimeType::create):
(WebCore::DOMMimeType::navigator):
* plugins/DOMMimeType.idl:
* plugins/DOMMimeTypeArray.cpp:
(WebCore::DOMMimeTypeArray::DOMMimeTypeArray):
(WebCore::DOMMimeTypeArray::length const):
(WebCore::DOMMimeTypeArray::item):
(WebCore::DOMMimeTypeArray::namedItem):
(WebCore::DOMMimeTypeArray::supportedPropertyNames):
(WebCore::DOMMimeTypeArray::getPluginData const): Deleted.
* plugins/DOMMimeTypeArray.h:
* plugins/DOMPlugin.cpp:
(WebCore::DOMPlugin::DOMPlugin):
(WebCore::DOMPlugin::item):
(WebCore::DOMPlugin::namedItem):
(WebCore::DOMPlugin::supportedPropertyNames):
* plugins/DOMPlugin.h:
* plugins/DOMPlugin.idl:
* plugins/DOMPluginArray.cpp:
(WebCore::DOMPluginArray::DOMPluginArray):
(WebCore::DOMPluginArray::length const):
(WebCore::DOMPluginArray::item):
(WebCore::DOMPluginArray::namedItem):
(WebCore::DOMPluginArray::supportedPropertyNames):
(WebCore::DOMPluginArray::pluginData const): Deleted.
* plugins/DOMPluginArray.h:
Rather than dynamically accessing plugin information through Page
on each interaction with the DOM plugin objects, we now fully initialize
them on creation, allowing for correct wrapper caching and behavior if
plugins are added / removed (e.g. the arrays should not change).

* plugins/PluginData.cpp:
(WebCore::PluginData::initPlugins):
(WebCore::PluginData::publiclyVisiblePluginsAndAdditionalWebVisiblePlugins const):
(WebCore::PluginData::webVisibleMimeTypes const):
(WebCore::supportsMimeTypeForPlugins):
(WebCore::PluginData::supportsMimeType const):
(WebCore::PluginData::supportsWebVisibleMimeType const):
(WebCore::PluginData::supportsWebVisibleMimeTypeForURL const):
(WebCore::PluginData::pluginFileForWebVisibleMimeType const):
(WebCore::PluginData::publiclyVisiblePlugins const): Deleted.
(WebCore::PluginData::getWebVisibleMimesAndPluginIndices const): Deleted.
(WebCore::PluginData::getMimesAndPluginIndices const): Deleted.
(WebCore::PluginData::getMimesAndPluginIndiciesForPlugins const): Deleted.
(WebCore::PluginData::getPluginInfoForWebVisibleMimeType const): Deleted.
* plugins/PluginData.h:
Simplify interface by removing out parameter based getWebVisibleMimesAndPluginIndices
(and helpers) and adding more straigtword alternatives. getWebVisibleMimesAndPluginIndices
was useful for the old DOM plugin model, but now that the arrays are initialized all
together, it no longer provides an optimization. Instead, all callers really just want
a either a list of MimeClassInfos or to know if one is supported under a specific scenario,
so we now just expose that.

Source/WebKit:

* UIProcess/Plugins/PluginInfoStore.h:
Add missing #include that is now needed due to pruning of unnecessary #includes
in WebCore.

* WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp:
(WebKit::pluginSupportsExtension):
Update to use new webVisibleMimeTypes() rather than the clunky getWebVisibleMimesAndPluginIndices().

LayoutTests:

* http/tests/plugins/plugin-_javascript_-access-allow-all-plugins-expected.txt: Added.
* http/tests/plugins/plugin-_javascript_-access-allow-all-plugins.html: Added.
* http/tests/plugins/plugin-_javascript_-access-expected.txt:
* http/tests/plugins/plugin-_javascript_-access.html:
Split out internals.setShowAllPlugins(true) part of plugin-_javascript_-access.html to
allow the test to continue working now that navigator.plugins is immutable after
accessing it.

* platform/mac-wk1/TestExpectations:
* platform/mac-wk1/imported/w3c/web-platform-tests/html/webappapis/system-state-and-capabilities/the-navigator-object/navigator-pluginarray-expected.txt: Removed.
Remove imported/w3c/web-platform-tests/html/webappapis/system-state-and-capabilities/the-navigator-object/navigator-pluginarray.html
from TestExpectations now that it passes all the time.

Modified Paths

Added Paths

Removed Paths

  • trunk/LayoutTests/platform/mac-wk1/imported/w3c/web-platform-tests/html/webappapis/system-state-and-capabilities/

Diff

Modified: trunk/LayoutTests/ChangeLog (263016 => 263017)


--- trunk/LayoutTests/ChangeLog	2020-06-15 00:58:43 UTC (rev 263016)
+++ trunk/LayoutTests/ChangeLog	2020-06-15 02:07:08 UTC (rev 263017)
@@ -1,3 +1,23 @@
+2020-06-14  Sam Weinig  <[email protected]>
+
+        [WPT] html/webappapis/system-state-and-capabilities/the-navigator-object/navigator-pluginarray.html fails due to lack of caching of Plugin objects
+        https://bugs.webkit.org/show_bug.cgi?id=213185
+
+        Reviewed by Darin Adler.
+
+        * http/tests/plugins/plugin-_javascript_-access-allow-all-plugins-expected.txt: Added.
+        * http/tests/plugins/plugin-_javascript_-access-allow-all-plugins.html: Added.
+        * http/tests/plugins/plugin-_javascript_-access-expected.txt:
+        * http/tests/plugins/plugin-_javascript_-access.html:
+        Split out internals.setShowAllPlugins(true) part of plugin-_javascript_-access.html to
+        allow the test to continue working now that navigator.plugins is immutable after 
+        accessing it.
+        
+        * platform/mac-wk1/TestExpectations:
+        * platform/mac-wk1/imported/w3c/web-platform-tests/html/webappapis/system-state-and-capabilities/the-navigator-object/navigator-pluginarray-expected.txt: Removed.
+        Remove imported/w3c/web-platform-tests/html/webappapis/system-state-and-capabilities/the-navigator-object/navigator-pluginarray.html
+        from TestExpectations now that it passes all the time.
+
 2020-06-14  Pinki Gyanchandani  <[email protected]>
 
         Release Assert @ WebCore::RenderTreeBuilder::RenderTreeBuilder

Copied: trunk/LayoutTests/http/tests/plugins/plugin-_javascript_-access-allow-all-plugins-expected.txt (from rev 263016, trunk/LayoutTests/http/tests/plugins/plugin-_javascript_-access-expected.txt) (0 => 263017)


--- trunk/LayoutTests/http/tests/plugins/plugin-_javascript_-access-allow-all-plugins-expected.txt	                        (rev 0)
+++ trunk/LayoutTests/http/tests/plugins/plugin-_javascript_-access-allow-all-plugins-expected.txt	2020-06-15 02:07:08 UTC (rev 263017)
@@ -0,0 +1,37 @@
+Test: Confirm the plugin is present.
+
+Name: WebKit Test PlugIn
+
+Description: Simple Netscape plug-in that handles test content for WebKit
+
+Filename: TestNetscapePlugIn.plugin
+
+Mime Types:
+
+Type: application/x-webkit-test-netscape
+
+Description: test netscape content
+
+Suffixes: testnetscape
+
+
+Plugin.item() works.
+
+Plugin.namedItem() works.
+
+Type: image/png
+
+Description: PNG image
+
+Suffixes: png
+
+
+Plugin.item() works.
+
+Plugin.namedItem() works.
+
+PluginArray.item() works.
+
+PluginArray.namedItem() works.
+
+PASS! (Found the netscape test plugin on a non-local file!)

Copied: trunk/LayoutTests/http/tests/plugins/plugin-_javascript_-access-allow-all-plugins.html (from rev 263016, trunk/LayoutTests/http/tests/plugins/plugin-_javascript_-access.html) (0 => 263017)


--- trunk/LayoutTests/http/tests/plugins/plugin-_javascript_-access-allow-all-plugins.html	                        (rev 0)
+++ trunk/LayoutTests/http/tests/plugins/plugin-_javascript_-access-allow-all-plugins.html	2020-06-15 02:07:08 UTC (rev 263017)
@@ -0,0 +1,69 @@
+<html>
+<head>
+    <meta http-equiv="content-type" content="text/html; charset=UTF-8">
+    <title>Installed Plug-ins</title>
+</head>
+<body>
+<script type="application/x-_javascript_">
+function checkForTestPlugin() {
+    for (var i = 0; i < navigator.plugins.length; i++) {
+        var plugin = navigator.plugins[i];
+
+        // We can only guarantee that the Test PlugIn is installed.
+        if (plugin.name != "WebKit Test PlugIn")
+            continue;
+
+        document.writeln("<p>Name: " + plugin.name + "<\/p>");
+        document.writeln("<p>Description: " + plugin.description + "<\/p>");
+        document.writeln("<p>Filename: " + plugin.filename + "<\/p>");
+
+        document.writeln("<p>Mime Types:<\/p>");
+        for (var mi = 0; mi != plugin.length; ++mi) {
+            document.writeln("<p>Type: " + plugin[mi].type + "<\/p>");
+            document.writeln("<p>Description: " + plugin[mi].description + "<\/p>");
+            document.writeln("<p>Suffixes: " + plugin[mi].suffixes + "<\/p>");
+            document.writeln("<br>");
+
+            if (plugin.item(mi).type == plugin[mi].type)
+                document.writeln("<p>Plugin.item() works.<\/p>");
+            else
+                document.writeln("<p>FAIL. Plugin.item() does not work.<\/p>");
+
+            if (plugin.namedItem(plugin[mi].type).type == plugin[mi].type)
+                document.writeln("<p>Plugin.namedItem() works.<\/p>");
+            else
+                document.writeln("<p>FAIL. Plugin.namedItem() does not work.<\/p>");
+        }
+
+        if (navigator.plugins.item(i).name == plugin.name)
+            document.writeln("<p>PluginArray.item() works.<\/p>");
+        else
+            document.writeln("<p>FAIL. PluginArray.item() does not work.<\/p>");
+
+        if (navigator.plugins.namedItem(plugin.name).name == plugin.name)
+            document.writeln("<p>PluginArray.namedItem() works.<\/p>");
+        else
+            document.writeln("<p>FAIL. PluginArray.namedItem() does not work.<\/p>");
+
+        return true;
+    }
+
+    return false;
+}
+   
+if (window.testRunner)
+    testRunner.dumpAsText()
+
+// Activate our debugging code to show all plugins to confirm we do have the test plugin.
+  document.writeln("<p>Test: Confirm the plugin is present.<\/p>");
+if (window.internals)
+    internals.setShowAllPlugins(true);
+
+if (checkForTestPlugin())
+    document.writeln("<p>PASS!  (Found the netscape test plugin on a non-local file!)<\/p>");
+else
+    document.writeln("<p>FAILURE!  (Could not find netscape test plugin on a non-local file!)<\/p>");
+
+</script>
+</body>
+</html>

Modified: trunk/LayoutTests/http/tests/plugins/plugin-_javascript_-access-expected.txt (263016 => 263017)


--- trunk/LayoutTests/http/tests/plugins/plugin-_javascript_-access-expected.txt	2020-06-15 00:58:43 UTC (rev 263016)
+++ trunk/LayoutTests/http/tests/plugins/plugin-_javascript_-access-expected.txt	2020-06-15 02:07:08 UTC (rev 263017)
@@ -1,41 +1,3 @@
-Test 1: A non-local file should not be able to iterate over the plugins.
+Test: A non-local file should not be able to iterate over the plugins.
 
 PASS! (Could not find the netscape test plugin on a non-local file!)
-
-Test 2: Confirm the plugin is present.
-
-Name: WebKit Test PlugIn
-
-Description: Simple Netscape plug-in that handles test content for WebKit
-
-Filename: TestNetscapePlugIn.plugin
-
-Mime Types:
-
-Type: application/x-webkit-test-netscape
-
-Description: test netscape content
-
-Suffixes: testnetscape
-
-
-Plugin.item() works.
-
-Plugin.namedItem() works.
-
-Type: image/png
-
-Description: PNG image
-
-Suffixes: png
-
-
-Plugin.item() works.
-
-Plugin.namedItem() works.
-
-PluginArray.item() works.
-
-PluginArray.namedItem() works.
-
-PASS! (Found the netscape test plugin on a non-local file!)

Modified: trunk/LayoutTests/http/tests/plugins/plugin-_javascript_-access.html (263016 => 263017)


--- trunk/LayoutTests/http/tests/plugins/plugin-_javascript_-access.html	2020-06-15 00:58:43 UTC (rev 263016)
+++ trunk/LayoutTests/http/tests/plugins/plugin-_javascript_-access.html	2020-06-15 02:07:08 UTC (rev 263017)
@@ -57,21 +57,12 @@
 navigator.plugins.refresh(false); // Supposedly helps if new plug-ins were added.
 
 // A non-local file should not be allowed to iterate over the installed plugins.
-document.writeln("<p>Test 1: A non-local file should not be able to iterate over the plugins.<\/p>");
+document.writeln("<p>Test: A non-local file should not be able to iterate over the plugins.<\/p>");
 if (checkForTestPlugin())
     document.writeln("<p>FAILURE!  (Found the netscape test plugin on a non-local file!)<\/p>");
 else
     document.writeln("<p>PASS!  (Could not find the netscape test plugin on a non-local file!)<\/p>");
 
-// Activate our debugging code to show all plugins to confirm we do have the test plugin.
-document.writeln("<p>Test 2: Confirm the plugin is present.<\/p>");
-if (window.internals)
-    internals.setShowAllPlugins(true);
-
-if (checkForTestPlugin())
-    document.writeln("<p>PASS!  (Found the netscape test plugin on a non-local file!)<\/p>");
-else
-    document.writeln("<p>FAILURE!  (Could not find netscape test plugin on a non-local file!)<\/p>");
 </script>
 </body>
 </html>

Modified: trunk/LayoutTests/imported/w3c/ChangeLog (263016 => 263017)


--- trunk/LayoutTests/imported/w3c/ChangeLog	2020-06-15 00:58:43 UTC (rev 263016)
+++ trunk/LayoutTests/imported/w3c/ChangeLog	2020-06-15 02:07:08 UTC (rev 263017)
@@ -1,5 +1,15 @@
 2020-06-14  Sam Weinig  <[email protected]>
 
+        [WPT] html/webappapis/system-state-and-capabilities/the-navigator-object/navigator-pluginarray.html fails due to lack of caching of Plugin objects
+        https://bugs.webkit.org/show_bug.cgi?id=213185
+
+        Reviewed by Darin Adler.
+
+        * web-platform-tests/html/webappapis/system-state-and-capabilities/the-navigator-object/navigator-pluginarray-expected.txt:
+        Update results now that this test passes.
+
+2020-06-14  Sam Weinig  <[email protected]>
+
         [WPT] websockets/Close-reason-unpaired-surrogates.any.html fails due to failure to convert unpaired surrogates to replacement character for close reason
         https://bugs.webkit.org/show_bug.cgi?id=213182
 

Modified: trunk/LayoutTests/imported/w3c/web-platform-tests/html/webappapis/system-state-and-capabilities/the-navigator-object/navigator-pluginarray-expected.txt (263016 => 263017)


--- trunk/LayoutTests/imported/w3c/web-platform-tests/html/webappapis/system-state-and-capabilities/the-navigator-object/navigator-pluginarray-expected.txt	2020-06-15 00:58:43 UTC (rev 263016)
+++ trunk/LayoutTests/imported/w3c/web-platform-tests/html/webappapis/system-state-and-capabilities/the-navigator-object/navigator-pluginarray-expected.txt	2020-06-15 02:07:08 UTC (rev 263017)
@@ -1,6 +1,6 @@
 
 PASS Tests that named properties are not enumerable in navigator.plugins and navigator.mimeTypes 
-FAIL Tests that navigator.plugins and navigator.mimeTypes returns the same object when queried multiple times. assert_equals: expected object "[object Plugin]" but got object "[object Plugin]"
+PASS Tests that navigator.plugins and navigator.mimeTypes returns the same object when queried multiple times. 
 PASS Tests that navigator.plugins and navigator.mimeTypes does not return the same object on different frames. 
-FAIL Tests that navigator.plugins and navigator.mimeTypes returns plugins sorted in alphabetical order by plugin name. assert_less_than_equal: expected a number less than or equal to 0 but got 1
+PASS Tests that navigator.plugins and navigator.mimeTypes returns plugins sorted in alphabetical order by plugin name. 
 

Modified: trunk/LayoutTests/platform/mac-wk1/TestExpectations (263016 => 263017)


--- trunk/LayoutTests/platform/mac-wk1/TestExpectations	2020-06-15 00:58:43 UTC (rev 263016)
+++ trunk/LayoutTests/platform/mac-wk1/TestExpectations	2020-06-15 02:07:08 UTC (rev 263017)
@@ -482,7 +482,6 @@
 webkit.org/b/172222 imported/w3c/web-platform-tests/notifications/event-onclose.html [ Skip ]
 
 imported/w3c/web-platform-tests/html/browsers/history/the-history-interface/history_go_no_argument.html [ Pass Failure ]
-imported/w3c/web-platform-tests/html/webappapis/system-state-and-capabilities/the-navigator-object/navigator-pluginarray.html [ Pass Failure ]
 imported/w3c/web-platform-tests/html/browsers/history/the-history-interface/history_go_to_uri.html [ Pass Failure ]
 
 # Newly imported WPT tests that are flaky only on WK1.

Modified: trunk/Source/WebCore/CMakeLists.txt (263016 => 263017)


--- trunk/Source/WebCore/CMakeLists.txt	2020-06-15 00:58:43 UTC (rev 263016)
+++ trunk/Source/WebCore/CMakeLists.txt	2020-06-15 02:07:08 UTC (rev 263017)
@@ -945,6 +945,7 @@
     page/NavigatorID.idl
     page/NavigatorLanguage.idl
     page/NavigatorOnLine.idl
+    page/NavigatorPlugins.idl
     page/NavigatorServiceWorker.idl
     page/NavigatorShare.idl
     page/Performance.idl

Modified: trunk/Source/WebCore/ChangeLog (263016 => 263017)


--- trunk/Source/WebCore/ChangeLog	2020-06-15 00:58:43 UTC (rev 263016)
+++ trunk/Source/WebCore/ChangeLog	2020-06-15 02:07:08 UTC (rev 263017)
@@ -1,5 +1,123 @@
 2020-06-14  Sam Weinig  <[email protected]>
 
+        [WPT] html/webappapis/system-state-and-capabilities/the-navigator-object/navigator-pluginarray.html fails due to lack of caching of Plugin objects
+        https://bugs.webkit.org/show_bug.cgi?id=213185
+
+        Reviewed by Darin Adler.
+
+        Tests:
+        - Updates results for web-platform-tests/html/webappapis/system-state-and-capabilities/the-navigator-object/navigator-pluginarray.html
+          which now passes.
+        - Splits up http/tests/plugins/plugin-_javascript_-access.html, adding 
+          http/tests/plugins/plugin-_javascript_-access-allow-all-plugins.html
+          which tests the internals.setShowAllPlugins(true) case. This was
+          required now that the plugin and mimetype arrays are immutable after
+          creation.
+
+        Overhaul web exposed plugin APIs:
+        - All DOMPlugin and DOMMimeTypes are now created together (along with the DOMPluginArray and 
+          DOMMimeTypeArray) on first access of either navigator.plugins or navigator.mimeTypes.
+        - DOMPlugins are created and stored in the DOMPluginArray (fixing the initial lack of caching issue)
+        - DOMMimeTypes are created and stored in the DOMMimeTypeArray.
+        - DOMPlugins hold a strong reference to their associated DOMMimeType. The DOMMimeType has
+          a weak reference back to the DOMPlugin. This means for a single executation context, we only
+          ever create one DOMPlugin / DOMMimeType for each underlying plugin / mimetype.
+        - Update GC so that DOMPlugin and DOMMimeType (in addition to DOMPluginArray and DOMMimeTypeArray
+          which were already doing this) use navigator reachability for their lifetime. This is almost
+          correct, except if we ever implement DOMPluginArray.refresh(false) to match the spec, in which
+          case you could end up with some DOMPlugins and DOMMimeTypes that are marked as reachable when
+          they really are not, but only plugins that were removed. This seems so unlikely to matter that
+          implementing a more strict reachability function seems like the wrong way to go.
+
+        * CMakeLists.txt:
+        * DerivedSources-input.xcfilelist:
+        * DerivedSources.make:
+        * WebCore.xcodeproj/project.pbxproj:
+        Add NavigatorPlugins.idl
+
+        * loader/SubframeLoader.cpp:
+        (WebCore::findPluginMIMETypeFromURL):
+        (WebCore::logPluginRequest):
+        Simplify and cleanup code making use of the new webVisibleMimeTypes() rather than the
+        clunky getWebVisibleMimesAndPluginIndices().
+
+        * page/Navigator.cpp:
+        * page/Navigator.h:
+        (WebCore::Navigator::initializePluginAndMIMETypeArrays):
+        (WebCore::Navigator::plugins):
+        (WebCore::Navigator::mimeTypes):
+        Fully initialize Navigator.plugins/mimeTypes on first access of either, following
+        the specified behavior that they should not change after initial access for a script
+        execution context. This also ensures we always return the same wrappers for these
+        objects on multiple accesses, something the spec mandates but we failed to do prior.
+        In addition, we now correctly sort the plugins by name and mimeTypes by type, also as
+        specified.
+
+        * page/Navigator.idl:
+        * page/NavigatorPlugins.idl: Added.
+        Split NavigatorPlugins out of Navigator.idl as specified. No functional change but
+        makes things nicer when we match the spec closer.
+
+        * plugins/DOMMimeType.cpp:
+        (WebCore::DOMMimeType::DOMMimeType):
+        (WebCore::DOMMimeType::suffixes const):
+        (WebCore::DOMMimeType::enabledPlugin const):
+        * plugins/DOMMimeType.h:
+        (WebCore::DOMMimeType::create):
+        (WebCore::DOMMimeType::navigator):
+        * plugins/DOMMimeType.idl:
+        * plugins/DOMMimeTypeArray.cpp:
+        (WebCore::DOMMimeTypeArray::DOMMimeTypeArray):
+        (WebCore::DOMMimeTypeArray::length const):
+        (WebCore::DOMMimeTypeArray::item):
+        (WebCore::DOMMimeTypeArray::namedItem):
+        (WebCore::DOMMimeTypeArray::supportedPropertyNames):
+        (WebCore::DOMMimeTypeArray::getPluginData const): Deleted.
+        * plugins/DOMMimeTypeArray.h:
+        * plugins/DOMPlugin.cpp:
+        (WebCore::DOMPlugin::DOMPlugin):
+        (WebCore::DOMPlugin::item):
+        (WebCore::DOMPlugin::namedItem):
+        (WebCore::DOMPlugin::supportedPropertyNames):
+        * plugins/DOMPlugin.h:
+        * plugins/DOMPlugin.idl:
+        * plugins/DOMPluginArray.cpp:
+        (WebCore::DOMPluginArray::DOMPluginArray):
+        (WebCore::DOMPluginArray::length const):
+        (WebCore::DOMPluginArray::item):
+        (WebCore::DOMPluginArray::namedItem):
+        (WebCore::DOMPluginArray::supportedPropertyNames):
+        (WebCore::DOMPluginArray::pluginData const): Deleted.
+        * plugins/DOMPluginArray.h:
+        Rather than dynamically accessing plugin information through Page
+        on each interaction with the DOM plugin objects, we now fully initialize
+        them on creation, allowing for correct wrapper caching and behavior if
+        plugins are added / removed (e.g. the arrays should not change).
+        
+        * plugins/PluginData.cpp:
+        (WebCore::PluginData::initPlugins):
+        (WebCore::PluginData::publiclyVisiblePluginsAndAdditionalWebVisiblePlugins const):
+        (WebCore::PluginData::webVisibleMimeTypes const):
+        (WebCore::supportsMimeTypeForPlugins):
+        (WebCore::PluginData::supportsMimeType const):
+        (WebCore::PluginData::supportsWebVisibleMimeType const):
+        (WebCore::PluginData::supportsWebVisibleMimeTypeForURL const):
+        (WebCore::PluginData::pluginFileForWebVisibleMimeType const):
+        (WebCore::PluginData::publiclyVisiblePlugins const): Deleted.
+        (WebCore::PluginData::getWebVisibleMimesAndPluginIndices const): Deleted.
+        (WebCore::PluginData::getMimesAndPluginIndices const): Deleted.
+        (WebCore::PluginData::getMimesAndPluginIndiciesForPlugins const): Deleted.
+        (WebCore::PluginData::getPluginInfoForWebVisibleMimeType const): Deleted.
+        * plugins/PluginData.h:
+        Simplify interface by removing out parameter based getWebVisibleMimesAndPluginIndices
+        (and helpers) and adding more straigtword alternatives. getWebVisibleMimesAndPluginIndices
+        was useful for the old DOM plugin model, but now that the arrays are initialized all 
+        together, it no longer provides an optimization. Instead, all callers really just want
+        a either a list of MimeClassInfos or to know if one is supported under a specific scenario,
+        so we now just expose that.
+
+2020-06-14  Sam Weinig  <[email protected]>
+
         [WPT] websockets/Close-reason-unpaired-surrogates.any.html fails due to failure to convert unpaired surrogates to replacement character for close reason
         https://bugs.webkit.org/show_bug.cgi?id=213182
 

Modified: trunk/Source/WebCore/DerivedSources-input.xcfilelist (263016 => 263017)


--- trunk/Source/WebCore/DerivedSources-input.xcfilelist	2020-06-15 00:58:43 UTC (rev 263016)
+++ trunk/Source/WebCore/DerivedSources-input.xcfilelist	2020-06-15 02:07:08 UTC (rev 263017)
@@ -933,6 +933,7 @@
 $(PROJECT_DIR)/page/NavigatorIsLoggedIn.idl
 $(PROJECT_DIR)/page/NavigatorLanguage.idl
 $(PROJECT_DIR)/page/NavigatorOnLine.idl
+$(PROJECT_DIR)/page/NavigatorPlugins.idl
 $(PROJECT_DIR)/page/NavigatorServiceWorker.idl
 $(PROJECT_DIR)/page/NavigatorShare.idl
 $(PROJECT_DIR)/page/Performance.idl

Modified: trunk/Source/WebCore/DerivedSources-output.xcfilelist (263016 => 263017)


--- trunk/Source/WebCore/DerivedSources-output.xcfilelist	2020-06-15 00:58:43 UTC (rev 263016)
+++ trunk/Source/WebCore/DerivedSources-output.xcfilelist	2020-06-15 02:07:08 UTC (rev 263017)
@@ -1154,6 +1154,8 @@
 $(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/JSNavigatorMediaDevices.h
 $(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/JSNavigatorOnLine.cpp
 $(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/JSNavigatorOnLine.h
+$(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/JSNavigatorPlugins.cpp
+$(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/JSNavigatorPlugins.h
 $(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/JSNavigatorServiceWorker.cpp
 $(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/JSNavigatorServiceWorker.h
 $(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/JSNavigatorShare.cpp

Modified: trunk/Source/WebCore/DerivedSources.make (263016 => 263017)


--- trunk/Source/WebCore/DerivedSources.make	2020-06-15 00:58:43 UTC (rev 263016)
+++ trunk/Source/WebCore/DerivedSources.make	2020-06-15 02:07:08 UTC (rev 263017)
@@ -952,6 +952,7 @@
     $(WebCore)/page/NavigatorIsLoggedIn.idl \
     $(WebCore)/page/NavigatorLanguage.idl \
     $(WebCore)/page/NavigatorOnLine.idl \
+    $(WebCore)/page/NavigatorPlugins.idl \
     $(WebCore)/page/NavigatorServiceWorker.idl \
     $(WebCore)/page/NavigatorShare.idl \
     $(WebCore)/page/Performance.idl \

Modified: trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj (263016 => 263017)


--- trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj	2020-06-15 00:58:43 UTC (rev 263016)
+++ trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj	2020-06-15 02:07:08 UTC (rev 263017)
@@ -9887,6 +9887,7 @@
 		7AF9B20918CFB5F200C64BEF /* JSVTTRegion.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSVTTRegion.h; sourceTree = "<group>"; };
 		7AF9B20A18CFB5F300C64BEF /* JSVTTRegionList.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSVTTRegionList.cpp; sourceTree = "<group>"; };
 		7AF9B20B18CFB5F300C64BEF /* JSVTTRegionList.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSVTTRegionList.h; sourceTree = "<group>"; };
+		7C017C3D24969F1300DC0C02 /* NavigatorPlugins.idl */ = {isa = PBXFileReference; lastKnownFileType = text; path = NavigatorPlugins.idl; sourceTree = "<group>"; };
 		7C029C6D2493C8F800268204 /* ColorTypes.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ColorTypes.h; sourceTree = "<group>"; };
 		7C0CEF281E4A542C008DEB80 /* JSDOMConstructorBase.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSDOMConstructorBase.h; sourceTree = "<group>"; };
 		7C0CEF291E4A54D3008DEB80 /* JSDOMConstructorWithDocument.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSDOMConstructorWithDocument.h; sourceTree = "<group>"; };
@@ -21112,6 +21113,7 @@
 				6B507A23234BF34100BE7C62 /* NavigatorIsLoggedIn.idl */,
 				7C5BEA3B1E9EE77100CC517B /* NavigatorLanguage.idl */,
 				7C5BEA3C1E9EE77100CC517B /* NavigatorOnLine.idl */,
+				7C017C3D24969F1300DC0C02 /* NavigatorPlugins.idl */,
 				5182C24B1F313AE00059BA7C /* NavigatorServiceWorker.idl */,
 				1DC553FD211BA12A004B780E /* NavigatorShare.idl */,
 				00146288103CD1DE000B20DB /* OriginAccessEntry.cpp */,

Modified: trunk/Source/WebCore/loader/SubframeLoader.cpp (263016 => 263017)


--- trunk/Source/WebCore/loader/SubframeLoader.cpp	2020-06-15 00:58:43 UTC (rev 263016)
+++ trunk/Source/WebCore/loader/SubframeLoader.cpp	2020-06-15 02:07:08 UTC (rev 263017)
@@ -163,30 +163,25 @@
     return loadPlugin(ownerElement, url, mimeType, paramNames, paramValues, useFallback);
 }
 
-static String findPluginMIMETypeFromURL(Page* page, const String& url)
+static String findPluginMIMETypeFromURL(Page& page, const StringView& url)
 {
     if (!url)
-        return String();
+        return { };
 
     size_t dotIndex = url.reverseFind('.');
     if (dotIndex == notFound)
-        return String();
+        return { };
 
-    String extension = url.substring(dotIndex + 1);
+    auto extensionFromURL = url.substring(dotIndex + 1);
 
-    const PluginData& pluginData = page->pluginData();
-
-    Vector<MimeClassInfo> mimes;
-    Vector<size_t> mimePluginIndices;
-    pluginData.getWebVisibleMimesAndPluginIndices(mimes, mimePluginIndices);
-    for (auto& mime : mimes) {
-        for (auto& mimeExtension : mime.extensions) {
-            if (equalIgnoringASCIICase(extension, mimeExtension))
-                return mime.type;
+    for (auto& type : page.pluginData().webVisibleMimeTypes()) {
+        for (auto& extension : type.extensions) {
+            if (equalIgnoringASCIICase(extensionFromURL, extension))
+                return type.type;
         }
     }
 
-    return String();
+    return { };
 }
 
 static void logPluginRequest(Page* page, const String& mimeType, const String& url, bool success)
@@ -197,7 +192,7 @@
     String newMIMEType = mimeType;
     if (!newMIMEType) {
         // Try to figure out the MIME type from the URL extension.
-        newMIMEType = findPluginMIMETypeFromURL(page, url);
+        newMIMEType = findPluginMIMETypeFromURL(*page, url);
         if (!newMIMEType)
             return;
     }

Modified: trunk/Source/WebCore/page/Navigator.cpp (263016 => 263017)


--- trunk/Source/WebCore/page/Navigator.cpp	2020-06-15 00:58:43 UTC (rev 263016)
+++ trunk/Source/WebCore/page/Navigator.cpp	2020-06-15 02:07:08 UTC (rev 263017)
@@ -25,7 +25,9 @@
 
 #include "Chrome.h"
 #include "CookieJar.h"
+#include "DOMMimeType.h"
 #include "DOMMimeTypeArray.h"
+#include "DOMPlugin.h"
 #include "DOMPluginArray.h"
 #include "Document.h"
 #include "Frame.h"
@@ -195,6 +197,57 @@
     });
 }
 
+void Navigator::initializePluginAndMimeTypeArrays()
+{
+    if (m_plugins)
+        return;
+
+    auto* frame = this->frame();
+    if (!frame || !frame->page()) {
+        m_plugins = DOMPluginArray::create(*this);
+        m_mimeTypes = DOMMimeTypeArray::create(*this);
+        return;
+    }
+
+    auto [publiclyVisiblePlugins, additionalWebVisiblePlugins] = frame->page()->pluginData().publiclyVisiblePluginsAndAdditionalWebVisiblePlugins();
+
+    Vector<Ref<DOMPlugin>> publiclyVisibleDOMPlugins;
+    Vector<Ref<DOMPlugin>> additionalWebVisibleDOMPlugins;
+    Vector<Ref<DOMMimeType>> webVisibleDOMMimeTypes;
+
+    publiclyVisibleDOMPlugins.reserveInitialCapacity(publiclyVisiblePlugins.size());
+    for (auto& plugin : publiclyVisiblePlugins) {
+        auto wrapper = DOMPlugin::create(*this, plugin);
+        webVisibleDOMMimeTypes.appendVector(wrapper->mimeTypes());
+        publiclyVisibleDOMPlugins.uncheckedAppend(WTFMove(wrapper));
+    }
+
+    additionalWebVisibleDOMPlugins.reserveInitialCapacity(additionalWebVisiblePlugins.size());
+    for (auto& plugin : additionalWebVisiblePlugins) {
+        auto wrapper = DOMPlugin::create(*this, plugin);
+        webVisibleDOMMimeTypes.appendVector(wrapper->mimeTypes());
+        additionalWebVisibleDOMPlugins.uncheckedAppend(WTFMove(wrapper));
+    }
+
+    std::sort(publiclyVisibleDOMPlugins.begin(), publiclyVisibleDOMPlugins.end(), [](const Ref<DOMPlugin>& a, const Ref<DOMPlugin>& b) {
+        if (auto nameComparison = codePointCompare(a->info().name, b->info().name))
+            return nameComparison < 0;
+        return codePointCompareLessThan(a->info().bundleIdentifier, b->info().bundleIdentifier);
+    });
+
+    std::sort(webVisibleDOMMimeTypes.begin(), webVisibleDOMMimeTypes.end(), [](const Ref<DOMMimeType>& a, const Ref<DOMMimeType>& b) {
+        if (auto typeComparison = codePointCompare(a->type(), b->type()))
+            return typeComparison < 0;
+        return codePointCompareLessThan(a->enabledPlugin()->info().bundleIdentifier, b->enabledPlugin()->info().bundleIdentifier);
+    });
+
+    // NOTE: It is not necessary to sort additionalWebVisibleDOMPlugins, as they are only accessible via
+    // named property look up, so their order is not exposed.
+
+    m_plugins = DOMPluginArray::create(*this, WTFMove(publiclyVisibleDOMPlugins), WTFMove(additionalWebVisibleDOMPlugins));
+    m_mimeTypes = DOMMimeTypeArray::create(*this, WTFMove(webVisibleDOMMimeTypes));
+}
+
 DOMPluginArray& Navigator::plugins()
 {
     if (RuntimeEnabledFeatures::sharedFeatures().webAPIStatisticsEnabled()) {
@@ -201,8 +254,7 @@
         if (auto* frame = this->frame())
             ResourceLoadObserver::shared().logNavigatorAPIAccessed(*frame->document(), ResourceLoadStatistics::NavigatorAPI::Plugins);
     }
-    if (!m_plugins)
-        m_plugins = DOMPluginArray::create(*this);
+    initializePluginAndMimeTypeArrays();
     return *m_plugins;
 }
 
@@ -212,8 +264,7 @@
         if (auto* frame = this->frame())
             ResourceLoadObserver::shared().logNavigatorAPIAccessed(*frame->document(), ResourceLoadStatistics::NavigatorAPI::MimeTypes);
     }
-    if (!m_mimeTypes)
-        m_mimeTypes = DOMMimeTypeArray::create(*this);
+    initializePluginAndMimeTypeArrays();
     return *m_mimeTypes;
 }
 

Modified: trunk/Source/WebCore/page/Navigator.h (263016 => 263017)


--- trunk/Source/WebCore/page/Navigator.h	2020-06-15 00:58:43 UTC (rev 263016)
+++ trunk/Source/WebCore/page/Navigator.h	2020-06-15 02:07:08 UTC (rev 263017)
@@ -68,6 +68,8 @@
     void showShareData(ExceptionOr<ShareDataWithParsedURL&>, Ref<DeferredPromise>&&);
     explicit Navigator(ScriptExecutionContext*, DOMWindow&);
 
+    void initializePluginAndMimeTypeArrays();
+
     mutable RefPtr<ShareDataReader> m_loader;
     mutable bool m_hasPendingShare { false };
     mutable RefPtr<DOMPluginArray> m_plugins;

Modified: trunk/Source/WebCore/page/Navigator.idl (263016 => 263017)


--- trunk/Source/WebCore/page/Navigator.idl	2020-06-15 00:58:43 UTC (rev 263016)
+++ trunk/Source/WebCore/page/Navigator.idl	2020-06-15 02:07:08 UTC (rev 263017)
@@ -21,10 +21,7 @@
     GenerateIsReachable=ReachableFromDOMWindow,
     JSCustomMarkFunction,
 ] interface Navigator {
-    readonly attribute DOMPluginArray plugins;
-    readonly attribute DOMMimeTypeArray mimeTypes;
     readonly attribute boolean cookieEnabled;
-    boolean javaEnabled();
 
     [Conditional=NAVIGATOR_STANDALONE] readonly attribute boolean standalone;
 
@@ -35,5 +32,6 @@
 Navigator implements NavigatorLanguage;
 Navigator implements NavigatorMaxTouchPoints;
 Navigator implements NavigatorOnLine;
+Navigator implements NavigatorPlugins;
 Navigator implements NavigatorServiceWorker;
 Navigator implements NavigatorShare;

Added: trunk/Source/WebCore/page/NavigatorPlugins.idl (0 => 263017)


--- trunk/Source/WebCore/page/NavigatorPlugins.idl	                        (rev 0)
+++ trunk/Source/WebCore/page/NavigatorPlugins.idl	2020-06-15 02:07:08 UTC (rev 263017)
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2020 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+[
+    NoInterfaceObject
+] interface NavigatorPlugins {
+    [SameObject] readonly attribute DOMPluginArray plugins;
+    [SameObject] readonly attribute DOMMimeTypeArray mimeTypes;
+    boolean javaEnabled();
+};

Modified: trunk/Source/WebCore/plugins/DOMMimeType.cpp (263016 => 263017)


--- trunk/Source/WebCore/plugins/DOMMimeType.cpp	2020-06-15 00:58:43 UTC (rev 263016)
+++ trunk/Source/WebCore/plugins/DOMMimeType.cpp	2020-06-15 02:07:08 UTC (rev 263017)
@@ -20,41 +20,37 @@
 #include "DOMMimeType.h"
 
 #include "DOMPlugin.h"
-#include "Frame.h"
-#include "FrameLoader.h"
-#include "Page.h"
-#include "PluginData.h"
+#include "Navigator.h"
 #include <wtf/text/StringBuilder.h>
 
 namespace WebCore {
 
-DOMMimeType::DOMMimeType(RefPtr<PluginData>&& pluginData, Frame* frame, unsigned index)
-    : FrameDestructionObserver(frame)
-    , m_pluginData(WTFMove(pluginData))
+Ref<DOMMimeType> DOMMimeType::create(Navigator& navigator, const MimeClassInfo& info, DOMPlugin& enabledPlugin)
 {
-    Vector<MimeClassInfo> mimes;
-    Vector<size_t> mimePluginIndices;
-    m_pluginData->getWebVisibleMimesAndPluginIndices(mimes, mimePluginIndices);
-    m_mimeClassInfo = mimes[index];
-    m_pluginInfo = m_pluginData->webVisiblePlugins()[mimePluginIndices[index]];
+    return adoptRef(*new DOMMimeType(navigator, info, enabledPlugin));
 }
 
+DOMMimeType::DOMMimeType(Navigator& navigator, const MimeClassInfo& info, DOMPlugin& enabledPlugin)
+    : m_navigator(makeWeakPtr(navigator))
+    , m_info(info)
+    , m_enabledPlugin(makeWeakPtr(enabledPlugin))
+{
+}
+
 DOMMimeType::~DOMMimeType() = default;
 
 String DOMMimeType::type() const
 {
-    return m_mimeClassInfo.type;
+    return m_info.type;
 }
 
 String DOMMimeType::suffixes() const
 {
-    const Vector<String>& extensions = m_mimeClassInfo.extensions;
-
     StringBuilder builder;
-    for (size_t i = 0; i < extensions.size(); ++i) {
+    for (size_t i = 0; i < m_info.extensions.size(); ++i) {
         if (i)
             builder.append(',');
-        builder.append(extensions[i]);
+        builder.append(m_info.extensions[i]);
     }
     return builder.toString();
 }
@@ -61,18 +57,12 @@
 
 String DOMMimeType::description() const
 {
-    return m_mimeClassInfo.desc;
+    return m_info.desc;
 }
 
 RefPtr<DOMPlugin> DOMMimeType::enabledPlugin() const
 {
-    if (!m_frame || !m_frame->page() || !m_frame->page()->mainFrame().loader().arePluginsEnabled())
-        return nullptr;
-
-    Vector<MimeClassInfo> mimes;
-    Vector<size_t> mimePluginIndices;
-    m_pluginData->getWebVisibleMimesAndPluginIndices(mimes, mimePluginIndices);
-    return DOMPlugin::create(m_pluginData.get(), m_frame, m_pluginInfo);
+    return m_enabledPlugin.get();
 }
 
 } // namespace WebCore

Modified: trunk/Source/WebCore/plugins/DOMMimeType.h (263016 => 263017)


--- trunk/Source/WebCore/plugins/DOMMimeType.h	2020-06-15 00:58:43 UTC (rev 263016)
+++ trunk/Source/WebCore/plugins/DOMMimeType.h	2020-06-15 02:07:08 UTC (rev 263017)
@@ -19,18 +19,19 @@
 
 #pragma once
 
-#include "FrameDestructionObserver.h"
 #include "PluginData.h"
 #include <wtf/RefCounted.h>
 #include <wtf/RefPtr.h>
+#include <wtf/WeakPtr.h>
 
 namespace WebCore {
 
 class DOMPlugin;
+class Navigator;
 
-class DOMMimeType : public RefCounted<DOMMimeType>, public FrameDestructionObserver {
+class DOMMimeType : public RefCounted<DOMMimeType> {
 public:
-    static Ref<DOMMimeType> create(RefPtr<PluginData>&& pluginData, Frame* frame, unsigned index) { return adoptRef(*new DOMMimeType(WTFMove(pluginData), frame, index)); }
+    static Ref<DOMMimeType> create(Navigator&, const MimeClassInfo&, DOMPlugin&);
     ~DOMMimeType();
 
     String type() const;
@@ -38,11 +39,14 @@
     String description() const;
     RefPtr<DOMPlugin> enabledPlugin() const;
 
+    Navigator* navigator() { return m_navigator.get(); }
+
 private:
-    DOMMimeType(RefPtr<PluginData>&&, Frame*, unsigned index);
-    MimeClassInfo m_mimeClassInfo;
-    RefPtr<PluginData> m_pluginData;
-    PluginInfo m_pluginInfo;
+    DOMMimeType(Navigator&, const MimeClassInfo&, DOMPlugin&);
+
+    WeakPtr<Navigator> m_navigator;
+    MimeClassInfo m_info;
+    WeakPtr<DOMPlugin> m_enabledPlugin;
 };
 
 } // namespace WebCore

Modified: trunk/Source/WebCore/plugins/DOMMimeType.idl (263016 => 263017)


--- trunk/Source/WebCore/plugins/DOMMimeType.idl	2020-06-15 00:58:43 UTC (rev 263016)
+++ trunk/Source/WebCore/plugins/DOMMimeType.idl	2020-06-15 02:07:08 UTC (rev 263017)
@@ -19,7 +19,9 @@
 */
 
 [
-    InterfaceName=MimeType
+    InterfaceName=MimeType,
+    GenerateIsReachable=ReachableFromNavigator,
+    ImplementationLacksVTable
 ] interface DOMMimeType {
     readonly attribute DOMString type;
     readonly attribute DOMString suffixes;

Modified: trunk/Source/WebCore/plugins/DOMMimeTypeArray.cpp (263016 => 263017)


--- trunk/Source/WebCore/plugins/DOMMimeTypeArray.cpp	2020-06-15 00:58:43 UTC (rev 263016)
+++ trunk/Source/WebCore/plugins/DOMMimeTypeArray.cpp	2020-06-15 02:07:08 UTC (rev 263017)
@@ -20,10 +20,8 @@
 #include "config.h"
 #include "DOMMimeTypeArray.h"
 
-#include "DOMPlugin.h"
-#include "Frame.h"
-#include "Page.h"
-#include "PluginData.h"
+#include "DOMMimeType.h"
+#include "Navigator.h"
 #include <wtf/IsoMallocInlines.h>
 #include <wtf/text/AtomString.h>
 
@@ -31,8 +29,14 @@
 
 WTF_MAKE_ISO_ALLOCATED_IMPL(DOMMimeTypeArray);
 
-DOMMimeTypeArray::DOMMimeTypeArray(Navigator& navigator)
+Ref<DOMMimeTypeArray> DOMMimeTypeArray::create(Navigator& navigator, Vector<Ref<DOMMimeType>>&& types)
+{
+    return adoptRef(*new DOMMimeTypeArray(navigator, WTFMove(types)));
+}
+
+DOMMimeTypeArray::DOMMimeTypeArray(Navigator& navigator, Vector<Ref<DOMMimeType>>&& types)
     : m_navigator(makeWeakPtr(navigator))
+    , m_types(WTFMove(types))
 {
 }
 
@@ -40,43 +44,21 @@
 
 unsigned DOMMimeTypeArray::length() const
 {
-    PluginData* data = ""
-    if (!data)
-        return 0;
-
-    Vector<MimeClassInfo> mimes;
-    Vector<size_t> mimePluginIndices;
-    data->getWebVisibleMimesAndPluginIndices(mimes, mimePluginIndices);
-    return mimes.size();
+    return m_types.size();
 }
 
 RefPtr<DOMMimeType> DOMMimeTypeArray::item(unsigned index)
 {
-    PluginData* data = ""
-    if (!data)
+    if (index >= m_types.size())
         return nullptr;
-
-    Vector<MimeClassInfo> mimes;
-    Vector<size_t> mimePluginIndices;
-    data->getWebVisibleMimesAndPluginIndices(mimes, mimePluginIndices);
-
-    if (index >= mimes.size())
-        return nullptr;
-    return DOMMimeType::create(data, frame(), index);
+    return m_types[index].ptr();
 }
 
 RefPtr<DOMMimeType> DOMMimeTypeArray::namedItem(const AtomString& propertyName)
 {
-    PluginData* data = ""
-    if (!data)
-        return nullptr;
-
-    Vector<MimeClassInfo> mimes;
-    Vector<size_t> mimePluginIndices;
-    data->getWebVisibleMimesAndPluginIndices(mimes, mimePluginIndices);
-    for (unsigned i = 0; i < mimes.size(); ++i) {
-        if (mimes[i].type == propertyName)
-            return DOMMimeType::create(data, frame(), i);
+    for (auto& type : m_types) {
+        if (type->type() == propertyName)
+            return type.ptr();
     }
     return nullptr;
 }
@@ -83,33 +65,11 @@
 
 Vector<AtomString> DOMMimeTypeArray::supportedPropertyNames()
 {
-    PluginData* data = ""
-    if (!data)
-        return { };
-
-    Vector<MimeClassInfo> mimes;
-    Vector<size_t> mimePluginIndices;
-    data->getWebVisibleMimesAndPluginIndices(mimes, mimePluginIndices);
-
     Vector<AtomString> result;
-    result.reserveInitialCapacity(mimes.size());
-    for (auto& info : mimes)
-        result.uncheckedAppend(WTFMove(info.type));
-
+    result.reserveInitialCapacity(m_types.size());
+    for (auto& type : m_types)
+        result.uncheckedAppend(type->type());
     return result;
 }
 
-PluginData* DOMMimeTypeArray::getPluginData() const
-{
-    auto* frame = this->frame();
-    if (!frame)
-        return nullptr;
-
-    auto* page = frame->page();
-    if (!page)
-        return nullptr;
-
-    return &page->pluginData();
-}
-
 } // namespace WebCore

Modified: trunk/Source/WebCore/plugins/DOMMimeTypeArray.h (263016 => 263017)


--- trunk/Source/WebCore/plugins/DOMMimeTypeArray.h	2020-06-15 00:58:43 UTC (rev 263016)
+++ trunk/Source/WebCore/plugins/DOMMimeTypeArray.h	2020-06-15 02:07:08 UTC (rev 263017)
@@ -20,19 +20,21 @@
 
 #pragma once
 
-#include "DOMMimeType.h"
-#include "Navigator.h"
 #include "ScriptWrappable.h"
+#include <wtf/Ref.h>
 #include <wtf/RefCounted.h>
+#include <wtf/Vector.h>
+#include <wtf/WeakPtr.h>
 
 namespace WebCore {
 
-class PluginData;
+class DOMMimeType;
+class Navigator;
 
 class DOMMimeTypeArray final : public ScriptWrappable, public RefCounted<DOMMimeTypeArray> {
     WTF_MAKE_ISO_ALLOCATED(DOMMimeTypeArray);
 public:
-    static Ref<DOMMimeTypeArray> create(Navigator& navigator) { return adoptRef(*new DOMMimeTypeArray(navigator)); }
+    static Ref<DOMMimeTypeArray> create(Navigator&, Vector<Ref<DOMMimeType>>&& = { });
     ~DOMMimeTypeArray();
 
     unsigned length() const;
@@ -39,15 +41,14 @@
     RefPtr<DOMMimeType> item(unsigned index);
     RefPtr<DOMMimeType> namedItem(const AtomString& propertyName);
     Vector<AtomString> supportedPropertyNames();
-    
+
     Navigator* navigator() { return m_navigator.get(); }
 
 private:
-    explicit DOMMimeTypeArray(Navigator&);
-    PluginData* getPluginData() const;
-    Frame* frame() const { return m_navigator ? m_navigator->frame() : nullptr; }
+    explicit DOMMimeTypeArray(Navigator&, Vector<Ref<DOMMimeType>>&&);
     
     WeakPtr<Navigator> m_navigator;
+    Vector<Ref<DOMMimeType>> m_types;
 };
 
 } // namespace WebCore

Modified: trunk/Source/WebCore/plugins/DOMPlugin.cpp (263016 => 263017)


--- trunk/Source/WebCore/plugins/DOMPlugin.cpp	2020-06-15 00:58:43 UTC (rev 263016)
+++ trunk/Source/WebCore/plugins/DOMPlugin.cpp	2020-06-15 02:07:08 UTC (rev 263017)
@@ -19,8 +19,8 @@
 #include "config.h"
 #include "DOMPlugin.h"
 
-#include "PluginData.h"
-#include "Frame.h"
+#include "DOMMimeType.h"
+#include "Navigator.h"
 #include <wtf/IsoMallocInlines.h>
 #include <wtf/text/AtomString.h>
 
@@ -28,71 +28,77 @@
 
 WTF_MAKE_ISO_ALLOCATED_IMPL(DOMPlugin);
 
-DOMPlugin::DOMPlugin(PluginData* pluginData, Frame* frame, PluginInfo pluginInfo)
-    : FrameDestructionObserver(frame)
-    , m_pluginData(pluginData)
-    , m_pluginInfo(WTFMove(pluginInfo))
+Ref<DOMPlugin> DOMPlugin::create(Navigator& navigator, const PluginInfo& info)
 {
+    return adoptRef(*new DOMPlugin(navigator, info));
 }
 
+static Vector<Ref<DOMMimeType>> makeMimeTypes(Navigator& navigator, const PluginInfo& info, DOMPlugin& self)
+{
+    Vector<Ref<DOMMimeType>> types;
+    types.reserveInitialCapacity(info.mimes.size());
+    for (auto& type : info.mimes)
+        types.uncheckedAppend(DOMMimeType::create(navigator, type, self));
+
+    std::sort(types.begin(), types.end(), [](const Ref<DOMMimeType>& a, const Ref<DOMMimeType>& b) {
+        return codePointCompareLessThan(a->type(), b->type());
+    });
+
+    return types;
+}
+
+DOMPlugin::DOMPlugin(Navigator& navigator, const PluginInfo& info)
+    : m_navigator(makeWeakPtr(navigator))
+    , m_info(info)
+    , m_mimeTypes(makeMimeTypes(navigator, info, *this))
+{
+}
+
 DOMPlugin::~DOMPlugin() = default;
 
 String DOMPlugin::name() const
 {
-    return m_pluginInfo.name;
+    return m_info.name;
 }
 
 String DOMPlugin::filename() const
 {
-    return m_pluginInfo.file;
+    return m_info.file;
 }
 
 String DOMPlugin::description() const
 {
-    return m_pluginInfo.desc;
+    return m_info.desc;
 }
 
 unsigned DOMPlugin::length() const
 {
-    return m_pluginInfo.mimes.size();
+    return m_mimeTypes.size();
 }
 
 RefPtr<DOMMimeType> DOMPlugin::item(unsigned index)
 {
-    if (index >= m_pluginInfo.mimes.size() || !m_frame || !m_frame->page())
+    if (index >= m_mimeTypes.size())
         return nullptr;
-
-    MimeClassInfo mime = m_pluginInfo.mimes[index];
-
-    Vector<MimeClassInfo> mimes;
-    Vector<size_t> mimePluginIndices;
-    Vector<PluginInfo> plugins = m_pluginData->webVisiblePlugins();
-    m_pluginData->getWebVisibleMimesAndPluginIndices(mimes, mimePluginIndices);
-    for (unsigned i = 0; i < mimes.size(); ++i) {
-        if (mimes[i] == mime && plugins[mimePluginIndices[i]] == m_pluginInfo)
-            return DOMMimeType::create(m_pluginData.get(), m_frame, i);
-    }
-    return nullptr;
+    return m_mimeTypes[index].ptr();
 }
 
 RefPtr<DOMMimeType> DOMPlugin::namedItem(const AtomString& propertyName)
 {
-    if (!m_frame || !m_frame->page())
-        return nullptr;
-
-    Vector<MimeClassInfo> mimes;
-    Vector<size_t> mimePluginIndices;
-    m_pluginData->getWebVisibleMimesAndPluginIndices(mimes, mimePluginIndices);
-    for (unsigned i = 0; i < mimes.size(); ++i)
-        if (mimes[i].type == propertyName)
-            return DOMMimeType::create(m_pluginData.get(), m_frame, i);
+    for (auto& type : m_mimeTypes) {
+        if (type->type() == propertyName)
+            return type.ptr();
+    }
     return nullptr;
 }
 
 Vector<AtomString> DOMPlugin::supportedPropertyNames()
 {
-    // FIXME: Should be implemented.
-    return Vector<AtomString>();
+    Vector<AtomString> result;
+    result.reserveInitialCapacity(m_mimeTypes.size());
+    for (auto& type : m_mimeTypes)
+        result.uncheckedAppend(type->type());
+    return result;
 }
 
 } // namespace WebCore

Modified: trunk/Source/WebCore/plugins/DOMPlugin.h (263016 => 263017)


--- trunk/Source/WebCore/plugins/DOMPlugin.h	2020-06-15 00:58:43 UTC (rev 263016)
+++ trunk/Source/WebCore/plugins/DOMPlugin.h	2020-06-15 02:07:08 UTC (rev 263017)
@@ -19,23 +19,25 @@
 
 #pragma once
 
-#include "FrameDestructionObserver.h"
-#include "DOMMimeType.h"
+#include "PluginData.h"
 #include "ScriptWrappable.h"
 #include <wtf/RefCounted.h>
 #include <wtf/RefPtr.h>
+#include <wtf/WeakPtr.h>
 
 namespace WebCore {
 
-class Plugin;
-class PluginData;
+class DOMMimeType;
+class Navigator;
 
-class DOMPlugin final : public ScriptWrappable, public RefCounted<DOMPlugin>, public FrameDestructionObserver {
+class DOMPlugin final : public ScriptWrappable, public RefCounted<DOMPlugin>, public CanMakeWeakPtr<DOMPlugin> {
     WTF_MAKE_ISO_ALLOCATED(DOMPlugin);
 public:
-    static Ref<DOMPlugin> create(PluginData* pluginData, Frame* frame, PluginInfo pluginInfo) { return adoptRef(*new DOMPlugin(pluginData, frame, WTFMove(pluginInfo))); }
+    static Ref<DOMPlugin> create(Navigator&, const PluginInfo&);
     ~DOMPlugin();
 
+    const PluginInfo& info() const { return m_info; }
+
     String name() const;
     String filename() const;
     String description() const;
@@ -46,10 +48,16 @@
     RefPtr<DOMMimeType> namedItem(const AtomString& propertyName);
     Vector<AtomString> supportedPropertyNames();
 
+    const Vector<Ref<DOMMimeType>>& mimeTypes() const { return m_mimeTypes; }
+
+    Navigator* navigator() { return m_navigator.get(); }
+
 private:
-    DOMPlugin(PluginData*, Frame*, PluginInfo);
-    RefPtr<PluginData> m_pluginData;
-    PluginInfo m_pluginInfo;
+    DOMPlugin(Navigator&, const PluginInfo&);
+
+    WeakPtr<Navigator> m_navigator;
+    PluginInfo m_info;
+    Vector<Ref<DOMMimeType>> m_mimeTypes;
 };
 
 } // namespace WebCore

Modified: trunk/Source/WebCore/plugins/DOMPlugin.idl (263016 => 263017)


--- trunk/Source/WebCore/plugins/DOMPlugin.idl	2020-06-15 00:58:43 UTC (rev 263016)
+++ trunk/Source/WebCore/plugins/DOMPlugin.idl	2020-06-15 02:07:08 UTC (rev 263017)
@@ -20,6 +20,8 @@
 
 [
     InterfaceName=Plugin,
+    GenerateIsReachable=ReachableFromNavigator,
+    ImplementationLacksVTable,
     LegacyUnenumerableNamedProperties
 ] interface DOMPlugin {
     readonly attribute DOMString name;

Modified: trunk/Source/WebCore/plugins/DOMPluginArray.cpp (263016 => 263017)


--- trunk/Source/WebCore/plugins/DOMPluginArray.cpp	2020-06-15 00:58:43 UTC (rev 263016)
+++ trunk/Source/WebCore/plugins/DOMPluginArray.cpp	2020-06-15 02:07:08 UTC (rev 263017)
@@ -23,7 +23,6 @@
 #include "DOMPlugin.h"
 #include "Frame.h"
 #include "Page.h"
-#include "PluginData.h"
 #include <wtf/IsoMallocInlines.h>
 #include <wtf/text/AtomString.h>
 
@@ -31,8 +30,15 @@
 
 WTF_MAKE_ISO_ALLOCATED_IMPL(DOMPluginArray);
 
-DOMPluginArray::DOMPluginArray(Navigator& navigator)
+Ref<DOMPluginArray> DOMPluginArray::create(Navigator& navigator, Vector<Ref<DOMPlugin>>&& publiclyVisiblePlugins, Vector<Ref<DOMPlugin>>&& additionalWebVisibilePlugins)
+{
+    return adoptRef(*new DOMPluginArray(navigator, WTFMove(publiclyVisiblePlugins), WTFMove(additionalWebVisibilePlugins)));
+}
+
+DOMPluginArray::DOMPluginArray(Navigator& navigator, Vector<Ref<DOMPlugin>>&& publiclyVisiblePlugins, Vector<Ref<DOMPlugin>>&& additionalWebVisibilePlugins)
     : m_navigator(makeWeakPtr(navigator))
+    , m_publiclyVisiblePlugins(WTFMove(publiclyVisiblePlugins))
+    , m_additionalWebVisibilePlugins(WTFMove(additionalWebVisibilePlugins))
 {
 }
 
@@ -40,57 +46,46 @@
 
 unsigned DOMPluginArray::length() const
 {
-    PluginData* data = ""
-    if (!data)
-        return 0;
-
-    return data->publiclyVisiblePlugins().size();
+    return m_publiclyVisiblePlugins.size();
 }
 
 RefPtr<DOMPlugin> DOMPluginArray::item(unsigned index)
 {
-    PluginData* data = ""
-    if (!data)
+    if (index >= m_publiclyVisiblePlugins.size())
         return nullptr;
-
-    const Vector<PluginInfo>& plugins = data->publiclyVisiblePlugins();
-    if (index >= plugins.size())
-        return nullptr;
-    return DOMPlugin::create(data, frame(), plugins[index]);
+    return m_publiclyVisiblePlugins[index].ptr();
 }
 
 RefPtr<DOMPlugin> DOMPluginArray::namedItem(const AtomString& propertyName)
 {
-    PluginData* data = ""
-    if (!data)
-        return nullptr;
+    for (auto& plugin : m_publiclyVisiblePlugins) {
+        if (plugin->name() == propertyName)
+            return plugin.ptr();
+    }
 
-    for (auto& plugin : data->webVisiblePlugins()) {
-        if (plugin.name == propertyName)
-            return DOMPlugin::create(data, frame(), plugin);
+    for (auto& plugin : m_additionalWebVisibilePlugins) {
+        if (plugin->name() == propertyName)
+            return plugin.ptr();
     }
+
     return nullptr;
 }
 
 Vector<AtomString> DOMPluginArray::supportedPropertyNames()
 {
-    PluginData* data = ""
-    if (!data)
-        return { };
-
-    const auto& plugins = data->publiclyVisiblePlugins();
-
     Vector<AtomString> result;
-    result.reserveInitialCapacity(plugins.size());
-    for (auto& plugin : plugins)
-        result.uncheckedAppend(plugin.name);
-
+    result.reserveInitialCapacity(m_publiclyVisiblePlugins.size());
+    for (auto& plugin : m_publiclyVisiblePlugins)
+        result.uncheckedAppend(plugin->name());
     return result;
 }
 
 void DOMPluginArray::refresh(bool reloadPages)
 {
-    auto* frame = this->frame();
+    if (!m_navigator)
+        return;
+
+    auto* frame = m_navigator->frame();
     if (!frame)
         return;
 
@@ -100,17 +95,4 @@
     Page::refreshPlugins(reloadPages);
 }
 
-PluginData* DOMPluginArray::pluginData() const
-{
-    auto* frame = this->frame();
-    if (!frame)
-        return nullptr;
-
-    Page* page = frame->page();
-    if (!page)
-        return nullptr;
-
-    return &page->pluginData();
-}
-
 } // namespace WebCore

Modified: trunk/Source/WebCore/plugins/DOMPluginArray.h (263016 => 263017)


--- trunk/Source/WebCore/plugins/DOMPluginArray.h	2020-06-15 00:58:43 UTC (rev 263016)
+++ trunk/Source/WebCore/plugins/DOMPluginArray.h	2020-06-15 02:07:08 UTC (rev 263017)
@@ -20,20 +20,22 @@
 
 #pragma once
 
-#include "DOMPlugin.h"
-#include "DOMWindowProperty.h"
 #include "Navigator.h"
 #include "ScriptWrappable.h"
+#include <wtf/Ref.h>
 #include <wtf/RefCounted.h>
+#include <wtf/Vector.h>
+#include <wtf/WeakPtr.h>
 
 namespace WebCore {
 
-class PluginData;
+class DOMPlugin;
+class Navigator;
 
 class DOMPluginArray final : public ScriptWrappable, public RefCounted<DOMPluginArray> {
     WTF_MAKE_ISO_ALLOCATED(DOMPluginArray);
 public:
-    static Ref<DOMPluginArray> create(Navigator& navigator) { return adoptRef(*new DOMPluginArray(navigator)); }
+    static Ref<DOMPluginArray> create(Navigator&, Vector<Ref<DOMPlugin>>&& = { }, Vector<Ref<DOMPlugin>>&& = { });
     ~DOMPluginArray();
 
     unsigned length() const;
@@ -42,16 +44,16 @@
     Vector<AtomString> supportedPropertyNames();
 
     void refresh(bool reloadPages);
+
+    Navigator* navigator() { return m_navigator.get(); }
     
-    Navigator* navigator() { return m_navigator.get(); }
-
 private:
-    explicit DOMPluginArray(Navigator&);
+    explicit DOMPluginArray(Navigator&, Vector<Ref<DOMPlugin>>&&, Vector<Ref<DOMPlugin>>&&);
 
-    PluginData* pluginData() const;
-    Frame* frame() const { return m_navigator ? m_navigator->frame() : nullptr; }
-    
+
     WeakPtr<Navigator> m_navigator;
+    Vector<Ref<DOMPlugin>> m_publiclyVisiblePlugins;
+    Vector<Ref<DOMPlugin>> m_additionalWebVisibilePlugins;
 };
 
 } // namespace WebCore

Modified: trunk/Source/WebCore/plugins/PluginData.cpp (263016 => 263017)


--- trunk/Source/WebCore/plugins/PluginData.cpp	2020-06-15 00:58:43 UTC (rev 263016)
+++ trunk/Source/WebCore/plugins/PluginData.cpp	2020-06-15 02:07:08 UTC (rev 263017)
@@ -29,6 +29,7 @@
 #include "LocalizedStrings.h"
 #include "Page.h"
 #include "PluginInfoProvider.h"
+#include <wtf/Optional.h>
 
 namespace WebCore {
 
@@ -38,6 +39,12 @@
     initPlugins();
 }
 
+void PluginData::initPlugins()
+{
+    ASSERT(m_plugins.isEmpty());
+    m_plugins = m_page.pluginInfoProvider().pluginInfo(m_page, m_supportedPluginIdentifiers);
+}
+
 const Vector<PluginInfo>& PluginData::webVisiblePlugins() const
 {
     auto documentURL = m_page.mainFrame().document() ? m_page.mainFrame().document()->url() : URL { };
@@ -80,120 +87,72 @@
         || isBuiltInPDFPlugIn(plugin);
 }
 
-Vector<PluginInfo> PluginData::publiclyVisiblePlugins() const
+std::pair<Vector<PluginInfo>, Vector<PluginInfo>> PluginData::publiclyVisiblePluginsAndAdditionalWebVisiblePlugins() const
 {
     auto plugins = webVisiblePlugins();
 
     if (m_page.showAllPlugins())
-        return plugins;
-    
-    plugins.removeAllMatching([](auto& plugin) {
-        return !shouldBePubliclyVisible(plugin);
-    });
+        return { plugins, { } };
 
-    std::sort(plugins.begin(), plugins.end(), [](const PluginInfo& a, const PluginInfo& b) {
-        return codePointCompareLessThan(a.name, b.name);
+    Vector<PluginInfo> additionalWebVisiblePlugins;
+    plugins.removeAllMatching([&](auto& plugin) {
+        if (!shouldBePubliclyVisible(plugin)) {
+            additionalWebVisiblePlugins.append(plugin);
+            return true;
+        }
+        return false;
     });
-    return plugins;
-}
 
-void PluginData::getWebVisibleMimesAndPluginIndices(Vector<MimeClassInfo>& mimes, Vector<size_t>& mimePluginIndices) const
-{
-    getMimesAndPluginIndiciesForPlugins(webVisiblePlugins(), mimes, mimePluginIndices);
+    return { plugins, additionalWebVisiblePlugins };
 }
 
-void PluginData::getMimesAndPluginIndices(Vector<MimeClassInfo>& mimes, Vector<size_t>& mimePluginIndices) const
+Vector<MimeClassInfo> PluginData::webVisibleMimeTypes() const
 {
-    getMimesAndPluginIndiciesForPlugins(plugins(), mimes, mimePluginIndices);
+    Vector<MimeClassInfo> result;
+    for (auto& plugin : webVisiblePlugins())
+        result.appendVector(plugin.mimes);
+    return result;
 }
 
-void PluginData::getMimesAndPluginIndiciesForPlugins(const Vector<PluginInfo>& plugins, Vector<MimeClassInfo>& mimes, Vector<size_t>& mimePluginIndices) const
+static bool supportsMimeTypeForPlugins(const String& mimeType, const PluginData::AllowedPluginTypes allowedPluginTypes, const Vector<PluginInfo>& plugins)
 {
-    ASSERT_ARG(mimes, mimes.isEmpty());
-    ASSERT_ARG(mimePluginIndices, mimePluginIndices.isEmpty());
-
-    for (unsigned i = 0; i < plugins.size(); ++i) {
-        const PluginInfo& plugin = plugins[i];
-        for (auto& mime : plugin.mimes) {
-            mimes.append(mime);
-            mimePluginIndices.append(i);
+    for (auto& plugin : plugins) {
+        for (auto& type : plugin.mimes) {
+            if (type.type == mimeType && (allowedPluginTypes == PluginData::AllPlugins || plugin.isApplicationPlugin))
+                return true;
         }
     }
+    return false;
 }
 
-bool PluginData::supportsWebVisibleMimeTypeForURL(const String& mimeType, const AllowedPluginTypes allowedPluginTypes, const URL& url) const
+bool PluginData::supportsMimeType(const String& mimeType, const AllowedPluginTypes allowedPluginTypes) const
 {
-    if (!protocolHostAndPortAreEqual(m_cachedVisiblePlugins.pageURL, url))
-        m_cachedVisiblePlugins = { url, m_page.pluginInfoProvider().webVisiblePluginInfo(m_page, url) };
-    if (!m_cachedVisiblePlugins.pluginList)
-        return false;
-    return supportsWebVisibleMimeType(mimeType, allowedPluginTypes, *m_cachedVisiblePlugins.pluginList);
+    return supportsMimeTypeForPlugins(mimeType, allowedPluginTypes, plugins());
 }
 
 bool PluginData::supportsWebVisibleMimeType(const String& mimeType, const AllowedPluginTypes allowedPluginTypes) const
 {
-    return supportsWebVisibleMimeType(mimeType, allowedPluginTypes, webVisiblePlugins());
+    return supportsMimeTypeForPlugins(mimeType, allowedPluginTypes, webVisiblePlugins());
 }
 
-bool PluginData::supportsWebVisibleMimeType(const String& mimeType, const AllowedPluginTypes allowedPluginTypes, const Vector<PluginInfo>& plugins) const
+bool PluginData::supportsWebVisibleMimeTypeForURL(const String& mimeType, const AllowedPluginTypes allowedPluginTypes, const URL& url) const
 {
-    Vector<MimeClassInfo> mimes;
-    Vector<size_t> mimePluginIndices;
-    getMimesAndPluginIndiciesForPlugins(plugins, mimes, mimePluginIndices);
-
-    for (unsigned i = 0; i < mimes.size(); ++i) {
-        if (mimes[i].type == mimeType && (allowedPluginTypes == AllPlugins || plugins[mimePluginIndices[i]].isApplicationPlugin))
-            return true;
-    }
-    return false;
+    if (!protocolHostAndPortAreEqual(m_cachedVisiblePlugins.pageURL, url))
+        m_cachedVisiblePlugins = { url, m_page.pluginInfoProvider().webVisiblePluginInfo(m_page, url) };
+    if (!m_cachedVisiblePlugins.pluginList)
+        return false;
+    return supportsMimeTypeForPlugins(mimeType, allowedPluginTypes, *m_cachedVisiblePlugins.pluginList);
 }
 
-bool PluginData::getPluginInfoForWebVisibleMimeType(const String& mimeType, PluginInfo& pluginInfoRef) const
+String PluginData::pluginFileForWebVisibleMimeType(const String& mimeType) const
 {
-    Vector<MimeClassInfo> mimes;
-    Vector<size_t> mimePluginIndices;
-    const Vector<PluginInfo>& plugins = webVisiblePlugins();
-    getWebVisibleMimesAndPluginIndices(mimes, mimePluginIndices);
-
-    for (unsigned i = 0; i < mimes.size(); ++i) {
-        const MimeClassInfo& info = mimes[i];
-
-        if (info.type == mimeType) {
-            pluginInfoRef = plugins[mimePluginIndices[i]];
-            return true;
+    for (auto& plugin : webVisiblePlugins()) {
+        for (auto& type : plugin.mimes) {
+            if (type.type == mimeType)
+                return plugin.file;
         }
     }
-
-    return false;
+    return { };
 }
 
-String PluginData::pluginFileForWebVisibleMimeType(const String& mimeType) const
-{
-    PluginInfo info;
-    if (getPluginInfoForWebVisibleMimeType(mimeType, info))
-        return info.file;
-    return String();
-}
-
-bool PluginData::supportsMimeType(const String& mimeType, const AllowedPluginTypes allowedPluginTypes) const
-{
-    Vector<MimeClassInfo> mimes;
-    Vector<size_t> mimePluginIndices;
-    const Vector<PluginInfo>& plugins = this->plugins();
-    getMimesAndPluginIndices(mimes, mimePluginIndices);
-
-    for (unsigned i = 0; i < mimes.size(); ++i) {
-        if (mimes[i].type == mimeType && (allowedPluginTypes == AllPlugins || plugins[mimePluginIndices[i]].isApplicationPlugin))
-            return true;
-    }
-    return false;
-}
-
-void PluginData::initPlugins()
-{
-    ASSERT(m_plugins.isEmpty());
-
-    m_plugins = m_page.pluginInfoProvider().pluginInfo(m_page, m_supportedPluginIdentifiers);
-}
-
 } // namespace WebCore

Modified: trunk/Source/WebCore/plugins/PluginData.h (263016 => 263017)


--- trunk/Source/WebCore/plugins/PluginData.h	2020-06-15 00:58:43 UTC (rev 263016)
+++ trunk/Source/WebCore/plugins/PluginData.h	2020-06-15 02:07:08 UTC (rev 263017)
@@ -21,8 +21,6 @@
 #pragma once
 
 #include <wtf/EnumTraits.h>
-#include <wtf/HashMap.h>
-#include <wtf/HashSet.h>
 #include <wtf/RefCounted.h>
 #include <wtf/URL.h>
 #include <wtf/Vector.h>
@@ -32,7 +30,6 @@
 namespace WebCore {
 
 class Page;
-struct PluginInfo;
 
 enum class PluginLoadClientPolicy : uint8_t {
     // No client-specific plug-in load policy has been defined. The plug-in should be visible in navigator.plugins and WebKit should synchronously
@@ -102,27 +99,23 @@
 
     const Vector<PluginInfo>& plugins() const { return m_plugins; }
     WEBCORE_EXPORT const Vector<PluginInfo>& webVisiblePlugins() const;
-    Vector<PluginInfo> publiclyVisiblePlugins() const;
-    WEBCORE_EXPORT void getWebVisibleMimesAndPluginIndices(Vector<MimeClassInfo>&, Vector<size_t>&) const;
+    std::pair<Vector<PluginInfo>, Vector<PluginInfo>> publiclyVisiblePluginsAndAdditionalWebVisiblePlugins() const;
 
+    WEBCORE_EXPORT Vector<MimeClassInfo> webVisibleMimeTypes() const;
+
     enum AllowedPluginTypes {
         AllPlugins,
         OnlyApplicationPlugins
     };
+    WEBCORE_EXPORT bool supportsMimeType(const String& mimeType, const AllowedPluginTypes) const;
+    WEBCORE_EXPORT bool supportsWebVisibleMimeType(const String& mimeType, const AllowedPluginTypes) const;
+    WEBCORE_EXPORT bool supportsWebVisibleMimeTypeForURL(const String& mimeType, const AllowedPluginTypes, const URL&) const;
 
-    WEBCORE_EXPORT bool supportsWebVisibleMimeType(const String& mimeType, const AllowedPluginTypes) const;
     String pluginFileForWebVisibleMimeType(const String& mimeType) const;
 
-    WEBCORE_EXPORT bool supportsMimeType(const String& mimeType, const AllowedPluginTypes) const;
-    WEBCORE_EXPORT bool supportsWebVisibleMimeTypeForURL(const String& mimeType, const AllowedPluginTypes, const URL&) const;
-
 private:
     explicit PluginData(Page&);
     void initPlugins();
-    bool getPluginInfoForWebVisibleMimeType(const String& mimeType, PluginInfo&) const;
-    void getMimesAndPluginIndices(Vector<MimeClassInfo>&, Vector<size_t>&) const;
-    void getMimesAndPluginIndiciesForPlugins(const Vector<PluginInfo>&, Vector<MimeClassInfo>&, Vector<size_t>&) const;
-    bool supportsWebVisibleMimeType(const String& mimeType, const AllowedPluginTypes, const Vector<PluginInfo>&) const;
 
 protected:
     Page& m_page;

Modified: trunk/Source/WebKit/ChangeLog (263016 => 263017)


--- trunk/Source/WebKit/ChangeLog	2020-06-15 00:58:43 UTC (rev 263016)
+++ trunk/Source/WebKit/ChangeLog	2020-06-15 02:07:08 UTC (rev 263017)
@@ -1,3 +1,18 @@
+2020-06-14  Sam Weinig  <[email protected]>
+
+        [WPT] html/webappapis/system-state-and-capabilities/the-navigator-object/navigator-pluginarray.html fails due to lack of caching of Plugin objects
+        https://bugs.webkit.org/show_bug.cgi?id=213185
+
+        Reviewed by Darin Adler.
+
+        * UIProcess/Plugins/PluginInfoStore.h:
+        Add missing #include that is now needed due to pruning of unnecessary #includes
+        in WebCore.
+
+        * WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp:
+        (WebKit::pluginSupportsExtension):
+        Update to use new webVisibleMimeTypes() rather than the clunky getWebVisibleMimesAndPluginIndices().
+
 2020-06-14  David Kilzer  <[email protected]>
 
         [IPC hardening] Return type of -[NSCoder validateClassSupportsSecureCoding:] is incorrect

Modified: trunk/Source/WebKit/UIProcess/Plugins/PluginInfoStore.h (263016 => 263017)


--- trunk/Source/WebKit/UIProcess/Plugins/PluginInfoStore.h	2020-06-15 00:58:43 UTC (rev 263016)
+++ trunk/Source/WebKit/UIProcess/Plugins/PluginInfoStore.h	2020-06-15 02:07:08 UTC (rev 263017)
@@ -30,6 +30,7 @@
 #include "PluginModuleInfo.h"
 
 #include <WebCore/PluginData.h>
+#include <wtf/HashSet.h>
 
 namespace WebKit {
 

Modified: trunk/Source/WebKit/WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp (263016 => 263017)


--- trunk/Source/WebKit/WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp	2020-06-15 00:58:43 UTC (rev 263016)
+++ trunk/Source/WebKit/WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp	2020-06-15 02:07:08 UTC (rev 263017)
@@ -1657,11 +1657,8 @@
 static bool pluginSupportsExtension(const PluginData& pluginData, const String& extension)
 {
     ASSERT(extension.convertToASCIILowercase() == extension);
-    Vector<MimeClassInfo> mimes;
-    Vector<size_t> mimePluginIndices;
-    pluginData.getWebVisibleMimesAndPluginIndices(mimes, mimePluginIndices);
-    for (auto& mimeClassInfo : mimes) {
-        if (mimeClassInfo.extensions.contains(extension))
+    for (auto& type : pluginData.webVisibleMimeTypes()) {
+        if (type.extensions.contains(extension))
             return true;
     }
     return false;
_______________________________________________
webkit-changes mailing list
[email protected]
https://lists.webkit.org/mailman/listinfo/webkit-changes

Reply via email to