Remove PluginLoadObserver and related logic, it was only used for NPAPI.

content/child/npapi/plugin_host.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/child/npapi/plugin_host.h"
 
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 333 matching lines @@
 
   scoped_refptr<PluginInstance> plugin(
       reinterpret_cast<PluginInstance*>(stream->ndata));
   if (!plugin.get())
     return NPERR_GENERIC_ERROR;
 
   plugin->RequestRead(stream, range_list);
   return NPERR_NO_ERROR;
 }
 
-// Generic form of GetURL for common code between GetURL and GetURLNotify.
-static NPError GetURLNotify(NPP id,
-                            const char* url,
-                            const char* target,
-                            bool notify,
-                            void* notify_data) {
-  if (!url)
-    return NPERR_INVALID_URL;
-
-  scoped_refptr<PluginInstance> plugin(FindInstance(id));
-  if (!plugin.get()) {
-    return NPERR_GENERIC_ERROR;
-  }
-
-  plugin->RequestURL(url, "GET", target, NULL, 0, notify, notify_data);
-  return NPERR_NO_ERROR;
-}
-
-// Requests creation of a new stream with the contents of the
-// specified URL; gets notification of the result.
 NPError NPN_GetURLNotify(NPP id,

[dcheng, 2015/11/18 18:38:18]

I feel like we should just nuke this one too.

[Nate Chapin, 2015/11/18 23:28:50]

These functions are referenced by the _NPPluginFuncs struct that is actually
exposed by the plugin API, so it's not clear to me it's right to drop them
entirely. We have several similarly stubbed functions in this file (e.g.,
NPN_HandleEvent and NPN_UnfocusInstance).

[dcheng, 2015/11/19 03:41:40]

Oops, sorry. I posted the comment on the wrong lines (I meant to nuke NPN_GetUrl
instead of copying part of the former implementation of NPN_GetUrlNotify over,
and similar for NPN_PostURL). Happily, that's exactly what happened anyway

                          const char* url,
                          const char* target,
                          void* notify_data) {
-  // This is identical to NPN_GetURL, but after finishing, the
-  // browser will call NPP_URLNotify to inform the plugin that
-  // it has completed.
-
-  // According to the NPAPI documentation, if target == _self
-  // or a parent to _self, the browser should return NPERR_INVALID_PARAM,
-  // because it can't notify the plugin once deleted.  This is
-  // absolutely false; firefox doesn't do this, and Flash relies on
-  // being able to use this.
-
-  // Also according to the NPAPI documentation, we should return
-  // NPERR_INVALID_URL if the url requested is not valid.  However,
-  // this would require that we synchronously start fetching the
-  // URL.  That just isn't practical.  As such, there really is
-  // no way to return this error.  From looking at the Firefox
-  // implementation, it doesn't look like Firefox does this either.
-
-  return GetURLNotify(id, url, target, true, notify_data);
+  return NPERR_GENERIC_ERROR;
 }
 
 NPError NPN_GetURL(NPP id, const char* url, const char* target) {
   // Notes:
   //    Request from the Plugin to fetch content either for the plugin
   //    or to be placed into a browser window.
   //
   // If target == null, the browser fetches content and streams to plugin.
   //    otherwise, the browser loads content into an existing browser frame.
   // If the target is the window/frame containing the plugin, the plugin
   //    may be destroyed.
   // If the target is _blank, a mailto: or news: url open content in a new
   //    browser window
   // If the target is _self, no other instance of the plugin is created.  The
   //    plugin continues to operate in its own window
-
-  return GetURLNotify(id, url, target, false, 0);
-}
-
-// Generic form of PostURL for common code between PostURL and PostURLNotify.
-static NPError PostURLNotify(NPP id,
-                             const char* url,
-                             const char* target,
-                             uint32_t len,
-                             const char* buf,
-                             NPBool file,
-                             bool notify,
-                             void* notify_data) {
   if (!url)
     return NPERR_INVALID_URL;
 
+  scoped_refptr<PluginInstance> plugin(FindInstance(id));
+  if (!plugin.get()) {
+    return NPERR_GENERIC_ERROR;
+  }
+
+  plugin->RequestURL(url, "GET", target, NULL, 0);
+  return NPERR_NO_ERROR;
+}
+
+NPError NPN_PostURLNotify(NPP id,

[dcheng, 2015/11/18 18:38:18]

Ditto: why not nuke?

[Nate Chapin, 2015/11/18 23:28:50]

See above.

+                    const char* url,
+                    const char* target,
+                    uint32_t len,
+                    const char* buf,
+                    NPBool file,
+                    void* notify_data) {
+  return NPERR_GENERIC_ERROR;
+}
+
+NPError NPN_PostURL(NPP id,
+                    const char* url,
+                    const char* target,
+                    uint32_t len,
+                    const char* buf,
+                    NPBool file) {
+  // POSTs data to an URL, either from a temp file or a buffer.
+  // If file is true, buf contains a temp file (which host will delete after
+  //   completing), and len contains the length of the filename.
+  // If file is false, buf contains the data to send, and len contains the
+  //   length of the buffer
+  //
+  // If target is null,
+  //   server response is returned to the plugin
+  // If target is _current, _self, or _top,
+  //   server response is written to the plugin window and plugin is unloaded.
+  // If target is _new or _blank,
+  //   server response is written to a new browser window
+  // If target is an existing frame,
+  //   server response goes to that frame.
+  //
+  // For protocols other than FTP
+  //   file uploads must be line-end converted from \r\n to \n
+
+  if (!url)
+    return NPERR_INVALID_URL;
+
   scoped_refptr<PluginInstance> plugin(FindInstance(id));
   if (!plugin.get()) {
     NOTREACHED();
     return NPERR_GENERIC_ERROR;
   }
 
   std::string post_file_contents;
 
   if (file) {
     // Post data to be uploaded from a file. This can be handled in two
@@ skipping 51 matching lines @@
   // The post data sent by a plugin contains both headers
   // and post data.  Example:
   //      Content-type: text/html
   //      Content-length: 200
   //
   //      <200 bytes of content here>
   //
   // Unfortunately, our stream needs these broken apart,
   // so we need to parse the data and set headers and data
   // separately.
-  plugin->RequestURL(url, "POST", target, buf, len, notify, notify_data);
+  plugin->RequestURL(url, "POST", target, buf, len);
   return NPERR_NO_ERROR;
 }
 
-NPError NPN_PostURLNotify(NPP id,
-                          const char* url,
-                          const char* target,
-                          uint32_t len,
-                          const char* buf,
-                          NPBool file,
-                          void* notify_data) {
-  return PostURLNotify(id, url, target, len, buf, file, true, notify_data);
-}
-
-NPError NPN_PostURL(NPP id,
-                    const char* url,
-                    const char* target,
-                    uint32_t len,
-                    const char* buf,
-                    NPBool file) {
-  // POSTs data to an URL, either from a temp file or a buffer.
-  // If file is true, buf contains a temp file (which host will delete after
-  //   completing), and len contains the length of the filename.
-  // If file is false, buf contains the data to send, and len contains the
-  //   length of the buffer
-  //
-  // If target is null,
-  //   server response is returned to the plugin
-  // If target is _current, _self, or _top,
-  //   server response is written to the plugin window and plugin is unloaded.
-  // If target is _new or _blank,
-  //   server response is written to a new browser window
-  // If target is an existing frame,
-  //   server response goes to that frame.
-  //
-  // For protocols other than FTP
-  //   file uploads must be line-end converted from \r\n to \n
-  //
-  // Note:  you cannot specify headers (even a blank line) in a memory buffer,
-  //        use NPN_PostURLNotify
-
-  return PostURLNotify(id, url, target, len, buf, file, false, 0);
-}
-
 NPError NPN_NewStream(NPP id,
                       NPMIMEType type,
                       const char* target,
                       NPStream** stream) {
   // Requests creation of a new data stream produced by the plugin,
   // consumed by the browser.
   //
   // Browser should put this stream into a window target.
   //
   // TODO: implement me
@@ skipping 539 matching lines @@
   return false;
 }
 
 NPBool NPN_UnfocusInstance(NPP id, NPFocusDirection direction) {
   // TODO: Implement advanced key handling: http://crbug.com/46578
   NOTIMPLEMENTED();
   return false;
 }
 
 void NPN_URLRedirectResponse(NPP instance, void* notify_data, NPBool allow) {
-  scoped_refptr<PluginInstance> plugin(FindInstance(instance));
-  if (plugin.get()) {
-    plugin->URLRedirectResponse(!!allow, notify_data);
-  }
 }
 
 }  // extern "C"