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

content/child/npapi/plugin_instance.h

 // 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.
 
 // TODO: Need to deal with NPAPI's NPSavedData.
 //       I haven't seen plugins use it yet.
 
 #ifndef CONTENT_CHILD_NPAPI_PLUGIN_INSTANCE_H_
 #define CONTENT_CHILD_NPAPI_PLUGIN_INSTANCE_H_
 
@@ skipping 103 matching lines @@
   // Updates the instance's tracking of the location of the plugin location
   // relative to the upper left of the screen.
   void set_plugin_origin(const gfx::Point& origin) { plugin_origin_ = origin; }
   // Updates the instance's tracking of the frame of the containing window
   // relative to the upper left of the screen.
   void set_window_frame(const gfx::Rect& frame) {
     containing_window_frame_ = frame;
   }
 #endif
 
-  // Creates a stream for sending an URL.  If notify_id is non-zero, it will
-  // send a notification to the plugin when the stream is complete; otherwise it
-  // will not.  Set object_url to true if the load is for the object tag's url,
-  // or false if it's for a url that the plugin fetched through
-  // NPN_GetUrl[Notify].
+  // Creates a stream for sending an URL. Set object_url to true if the load is
+  // for the object tag's url, or false if it's for a url that the plugin
+  // fetched through NPN_GetUrl[Notify].
   PluginStreamUrl* CreateStream(unsigned long resource_id,

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

Then we could probably nuke this too.

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

Done.

                                 const GURL& url,
-                                const std::string& mime_type,
-                                int notify_id);
+                                const std::string& mime_type);
 
   // For each instance, we track all streams.  When the
   // instance closes, all remaining streams are also
   // closed.  All streams associated with this instance
   // should call AddStream so that they can be cleaned
   // up when the instance shuts down.
   void AddStream(PluginStream* stream);
 
   // This is called when a stream is closed. We remove the stream from the
   // list, which releases the reference maintained to the stream.
   void RemoveStream(PluginStream* stream);
 
   // Closes all open streams on this instance.
   void CloseStreams();
 
   // Returns the WebPluginResourceClient object for a stream that has become
   // seekable.
   WebPluginResourceClient* GetRangeRequest(int id);
 
   // Have the plugin create its script object.
   NPObject* GetPluginScriptableObject();
 
   // Returns the form value of this instance.
   bool GetFormValue(base::string16* value);
 
-  // WebViewDelegate methods that we implement. This is for handling
-  // callbacks during getURLNotify.
-  void DidFinishLoadWithReason(const GURL& url, NPReason reason, int notify_id);
-
   // If true, send the Mozilla user agent instead of Chrome's to the plugin.
   bool use_mozilla_user_agent() { return use_mozilla_user_agent_; }
   void set_use_mozilla_user_agent() { use_mozilla_user_agent_ = true; }
 
   // If the plugin instance is backed by a texture, return its ID in the
   // compositor's namespace. Otherwise return 0. Returns 0 by default.
   unsigned GetBackingTextureId();
 
   // Helper that implements NPN_PluginThreadAsyncCall semantics
   void PluginThreadAsyncCall(void (*func)(void *),
@@ skipping 26 matching lines @@
   NPError NPP_GetValue(NPPVariable, void*);
   NPError NPP_SetValue(NPNVariable, void*);
   short NPP_HandleEvent(void*);
   void NPP_Destroy();
   bool NPP_Print(NPPrint* platform_print);
   void NPP_URLRedirectNotify(const char* url, int32_t status,
                              void* notify_data);
 
   void SendJavaScriptStream(const GURL& url,
                             const std::string& result,
-                            bool success,
-                            int notify_id);
+                            bool success);
 
   void DidReceiveManualResponse(const GURL& url,
                                 const std::string& mime_type,
                                 const std::string& headers,
                                 uint32 expected_length,
                                 uint32 last_modified);
   void DidReceiveManualData(const char* buffer, int length);
   void DidFinishManualLoading();
   void DidManualLoadFail();
 
   void PushPopupsEnabledState(bool enabled);
   void PopPopupsEnabledState();
 
   bool popups_allowed() const {
     return popups_enabled_stack_.empty() ? false : popups_enabled_stack_.top();
   }
 
   // Initiates byte range reads for plugins.
   void RequestRead(NPStream* stream, NPByteRange* range_list);
 
   // Handles GetURL/GetURLNotify/PostURL/PostURLNotify requests initiated
   // by plugins.
   void RequestURL(const char* url,
                   const char* method,
                   const char* target,
                   const char* buf,
-                  unsigned int len,
-                  bool notify,
-                  void* notify_data);
-
-  // Handles NPN_URLRedirectResponse calls issued by plugins in response to
-  // HTTP URL redirect notifications.
-  void URLRedirectResponse(bool allow, void* notify_data);
-
-  bool handles_url_redirects() const { return handles_url_redirects_; }
+                  unsigned int len);
 
  private:
   friend class base::RefCountedThreadSafe<PluginInstance>;
 
 #if defined(OS_MACOSX)
   friend class ScopedCurrentPluginEvent;
   // Sets the event that the plugin is currently handling. The object is not
   // owned or copied, so the caller must call this again with NULL before the
   // event pointer becomes invalid. Clients use ScopedCurrentPluginEvent rather
   // than calling this directly.
   void set_currently_handled_event(NPCocoaEvent* event) {
     currently_handled_event_ = event;
   }
 #endif
 
   ~PluginInstance();
   void OnPluginThreadAsyncCall(void (*func)(void *), void* userData);
   void OnTimerCall(void (*func)(NPP id, uint32 timer_id),
                    NPP id, uint32 timer_id);
   bool IsValidStream(const NPStream* stream);
-  void GetNotifyData(int notify_id, bool* notify, void** notify_data);
 
   // This is a hack to get the real player plugin to work with chrome
   // The real player plugin dll(nppl3260) when loaded by firefox is loaded via
   // the NS COM API which is analogous to win32 COM. So the NPAPI functions in
   // the plugin are invoked via an interface by firefox. The plugin instance
   // handle which is passed to every NPAPI method is owned by the real player
   // plugin, i.e. it expects the ndata member to point to a structure which
   // it knows about. Eventually it dereferences this structure and compares
   // a member variable at offset 0x24(Version 6.0.11.2888) /2D (Version
   // 6.0.11.3088) with 0 and on failing this check, takes  a different code
@@ skipping 55 matching lines @@
     uint32 interval;
     bool repeat;
   };
   typedef std::map<uint32, TimerInfo> TimerMap;
   TimerMap timers_;
 
   // Tracks pending GET/POST requests so that the plugin-given data doesn't
   // cross process boundaries to an untrusted process.
   typedef std::map<int, void*> PendingRequestMap;
   PendingRequestMap pending_requests_;
-  int next_notify_id_;
 
   // Used to track pending range requests so that when WebPlugin replies to us
   // we can match the reply to the stream.
   typedef std::map<int, scoped_refptr<PluginStream> > PendingRangeRequestMap;
   PendingRangeRequestMap pending_range_requests_;
   int next_range_request_id_;
   // The plugin handles the NPAPI URL redirect notification API.
   // See here https://wiki.mozilla.org/NPAPI:HTTPRedirectHandling
   bool handles_url_redirects_;
 
@@ skipping 11 matching lines @@
 
  private:
   scoped_refptr<PluginInstance> instance_;
   DISALLOW_COPY_AND_ASSIGN(ScopedCurrentPluginEvent);
 };
 #endif
 
 }  // namespace content
 
 #endif  // CONTENT_CHILD_NPAPI_PLUGIN_INSTANCE_H_