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

content/renderer/npapi/webplugin_delegate_proxy.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/renderer/npapi/webplugin_delegate_proxy.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/basictypes.h"
@@ skipping 84 matching lines @@
 // deleting itself after its callback has been called.
 class ResourceClientProxy : public WebPluginResourceClient {
  public:
   ResourceClientProxy(PluginChannelHost* channel, int instance_id)
     : channel_(channel), instance_id_(instance_id), resource_id_(0),
       multibyte_response_expected_(false) {
   }
 
   ~ResourceClientProxy() override {}
 
-  void Initialize(unsigned long resource_id, const GURL& url, int notify_id) {
+  void Initialize(unsigned long resource_id, const GURL& url) {
     resource_id_ = resource_id;
     channel_->Send(new PluginMsg_HandleURLRequestReply(
-        instance_id_, resource_id, url, notify_id));
+        instance_id_, resource_id, url));
   }
 
   void InitializeForSeekableStream(unsigned long resource_id,
                                    int range_request_id) {
     resource_id_ = resource_id;
     multibyte_response_expected_ = true;
     channel_->Send(new PluginMsg_HTTPRangeRequestReply(
         instance_id_, resource_id, range_request_id));
   }
 
@@ skipping 262 matching lines @@
     DLOG(WARNING) << "dropping message because channel host is null";
     delete msg;
     return false;
   }
 
   return channel_host_->Send(msg);
 }
 
 void WebPluginDelegateProxy::SendJavaScriptStream(const GURL& url,
                                                   const std::string& result,
-                                                  bool success,
-                                                  int notify_id) {
-  Send(new PluginMsg_SendJavaScriptStream(
-      instance_id_, url, result, success, notify_id));
+                                                  bool success) {
+  Send(new PluginMsg_SendJavaScriptStream(instance_id_, url, result, success));
 }
 
 void WebPluginDelegateProxy::DidReceiveManualResponse(
     const GURL& url, const std::string& mime_type,
     const std::string& headers, uint32 expected_length,
     uint32 last_modified) {
   PluginMsg_DidReceiveResponseParams params;
   params.id = 0;
   params.mime_type = mime_type;
   params.headers = headers;
@@ skipping 329 matching lines @@
   // Return a dummy NPP for WebKit to use to identify this plugin.
   return npp_.get();
 }
 
 bool WebPluginDelegateProxy::GetFormValue(base::string16* value) {
   bool success = false;
   Send(new PluginMsg_GetFormValue(instance_id_, value, &success));
   return success;
 }
 
-void WebPluginDelegateProxy::DidFinishLoadWithReason(
-    const GURL& url, NPReason reason, int notify_id) {
-  Send(new PluginMsg_DidFinishLoadWithReason(
-      instance_id_, url, reason, notify_id));
-}
-
 void WebPluginDelegateProxy::SetFocus(bool focused) {
   Send(new PluginMsg_SetFocus(instance_id_, focused));
 #if defined(OS_WIN)
   if (render_view_)
     render_view_->PluginFocusChanged(focused, instance_id_);
 #endif
 }
 
 bool WebPluginDelegateProxy::HandleInputEvent(
     const WebInputEvent& event,
@@ skipping 310 matching lines @@
   const char* data = NULL;
   if (params.buffer.size())
     data = &params.buffer[0];
 
   const char* target = NULL;
   if (params.target.length())
     target = params.target.c_str();
 
   plugin_->HandleURLRequest(
       params.url.c_str(), params.method.c_str(), target, data,
-      static_cast<unsigned int>(params.buffer.size()), params.notify_id,
+      static_cast<unsigned int>(params.buffer.size()),
       params.popups_allowed, params.notify_redirects);
 }
 
 WebPluginResourceClient* WebPluginDelegateProxy::CreateResourceClient(
-    unsigned long resource_id, const GURL& url, int notify_id) {
+    unsigned long resource_id, const GURL& url) {
   if (!channel_host_.get())
     return NULL;
 
   ResourceClientProxy* proxy =
       new ResourceClientProxy(channel_host_.get(), instance_id_);
-  proxy->Initialize(resource_id, url, notify_id);
+  proxy->Initialize(resource_id, url);
   return proxy;
 }
 
 WebPluginResourceClient* WebPluginDelegateProxy::CreateSeekableResourceClient(
     unsigned long resource_id, int range_request_id) {
   if (!channel_host_.get())
     return NULL;
 
   ResourceClientProxy* proxy =
       new ResourceClientProxy(channel_host_.get(), instance_id_);
   proxy->InitializeForSeekableStream(resource_id, range_request_id);
   return proxy;
 }
 
 void WebPluginDelegateProxy::FetchURL(unsigned long resource_id,
-                                      int notify_id,
                                       const GURL& url,
                                       const GURL& first_party_for_cookies,
                                       const std::string& method,
                                       const char* buf,
                                       unsigned int len,
                                       const Referrer& referrer,
                                       bool notify_redirects,
                                       bool is_plugin_src_load,
                                       int origin_pid,
                                       int render_frame_id,
                                       int render_view_id) {
   PluginMsg_FetchURL_Params params;
   params.resource_id = resource_id;
-  params.notify_id = notify_id;
   params.url = url;
   params.first_party_for_cookies = first_party_for_cookies;
   params.method = method;
   if (len) {
     params.post_data.resize(len);
     memcpy(&params.post_data.front(), buf, len);
   }
   params.referrer = referrer.url;
   params.referrer_policy = referrer.policy;
   params.notify_redirect = notify_redirects;
@@ skipping 95 matching lines @@
 
   plugin_->URLRedirectResponse(allow, resource_id);
 }
 
 void WebPluginDelegateProxy::OnCheckIfRunInsecureContent(const GURL& url,
                                                          bool* result) {
   *result = plugin_->CheckIfRunInsecureContent(url);
 }
 
 }  // namespace content