<webview>: Cleanup WebRequest event listeners when embedder destroyed

chrome/browser/extensions/api/web_request/web_request_api.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 "chrome/browser/extensions/api/web_request/web_request_api.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 379 matching lines @@
 // NOTE(benjhayden) New APIs should not use this sub_event_name trick! It does
 // not play well with event pages. See downloads.onDeterminingFilename and
 // ExtensionDownloadsEventRouter for an alternative approach.
 struct ExtensionWebRequestEventRouter::EventListener {
   std::string extension_id;
   std::string extension_name;
   std::string sub_event_name;
   RequestFilter filter;
   int extra_info_spec;
   int embedder_process_id;
-  int embedder_routing_id;
   int webview_instance_id;
   base::WeakPtr<IPC::Sender> ipc_sender;
   mutable std::set<uint64> blocked_requests;
 
   // Comparator to work with std::set.
   bool operator<(const EventListener& that) const {
     if (extension_id < that.extension_id)
       return true;
     if (extension_id == that.extension_id &&
         sub_event_name < that.sub_event_name)
@@ skipping 755 matching lines @@
 
 bool ExtensionWebRequestEventRouter::AddEventListener(
     void* profile,
     const std::string& extension_id,
     const std::string& extension_name,
     const std::string& event_name,
     const std::string& sub_event_name,
     const RequestFilter& filter,
     int extra_info_spec,
     int embedder_process_id,
-    int embedder_routing_id,
     int webview_instance_id,
     base::WeakPtr<IPC::Sender> ipc_sender) {
 
   if (!IsWebRequestEvent(event_name))
     return false;
 
   EventListener listener;
   listener.extension_id = extension_id;
   listener.extension_name = extension_name;
   listener.sub_event_name = sub_event_name;
   listener.filter = filter;
   listener.extra_info_spec = extra_info_spec;
   listener.ipc_sender = ipc_sender;
   listener.embedder_process_id = embedder_process_id;
-  listener.embedder_routing_id = embedder_routing_id;
   listener.webview_instance_id = webview_instance_id;
   if (listener.webview_instance_id)
     RecordAction(content::UserMetricsAction("WebView.WebRequest.AddListener"));
 
   if (listeners_[profile][event_name].count(listener) != 0u) {
     // This is likely an abuse of the API by a malicious extension.
     return false;
   }
   listeners_[profile][event_name].insert(listener);
   return true;
@@ skipping 32 matching lines @@
 
   listeners_[profile][event_name].erase(listener);
 
   helpers::ClearCacheOnNavigation();
 }
 
 void ExtensionWebRequestEventRouter::RemoveWebViewEventListeners(
     void* profile,
     const std::string& extension_id,
     int embedder_process_id,
-    int embedder_routing_id,
     int webview_instance_id) {
   // Iterate over all listeners of all WebRequest events to delete
   // any listeners that belong to the provided <webview>.
   ListenerMapForProfile& map_for_profile = listeners_[profile];
   for (ListenerMapForProfile::iterator event_iter = map_for_profile.begin();
        event_iter != map_for_profile.end(); ++event_iter) {
     std::vector<EventListener> listeners_to_delete;
     std::set<EventListener>& listeners = event_iter->second;
     for (std::set<EventListener>::iterator listener_iter = listeners.begin();
          listener_iter != listeners.end(); ++listener_iter) {
       const EventListener& listener = *listener_iter;
-      // TODO(fsamuel): Investigate making <webview> instance IDs unique within
-      // a process.
       if (listener.embedder_process_id == embedder_process_id &&
-          listener.embedder_routing_id == embedder_routing_id &&
           listener.webview_instance_id == webview_instance_id)
         listeners_to_delete.push_back(listener);
     }
     for (size_t i = 0; i < listeners_to_delete.size(); ++i) {
       EventListener& listener = listeners_to_delete[i];
       content::BrowserThread::PostTask(
           content::BrowserThread::UI,
           FROM_HERE,
           base::Bind(&RemoveEventListenerOnUI,
                      profile,
@@ skipping 101 matching lines @@
   for (std::set<EventListener>::iterator it = listeners.begin();
        it != listeners.end(); ++it) {
     if (!it->ipc_sender.get()) {
       // The IPC sender has been deleted. This listener will be removed soon
       // via a call to RemoveEventListener. For now, just skip it.
       continue;
     }
 
     if (is_guest &&
         (it->embedder_process_id != webview_info.embedder_process_id ||
-         it->embedder_routing_id != webview_info.embedder_routing_id ||
          it->webview_instance_id != webview_info.instance_id))
       continue;
 
     if (!it->filter.urls.is_empty() && !it->filter.urls.MatchesURL(url))
       continue;
     if (it->filter.tab_id != -1 && tab_id != it->filter.tab_id)
       continue;
     if (it->filter.window_id != -1 && window_id != it->filter.window_id)
       continue;
     if (!it->filter.types.empty() &&
@@ skipping 688 matching lines @@
   std::string sub_event_name;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(4, &sub_event_name));
 
   int webview_instance_id = 0;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(5, &webview_instance_id));
 
   base::WeakPtr<ChromeRenderMessageFilter> ipc_sender = ipc_sender_weak();
 
   int embedder_process_id =
       ipc_sender.get() ? ipc_sender->render_process_id() : -1;
-  int embedder_routing_id = routing_id();
 
   const Extension* extension =
       extension_info_map()->extensions().GetByID(extension_id());
   std::string extension_name = extension ? extension->name() : extension_id();
 
   bool is_guest = webview_instance_id != 0;
   // We check automatically whether the extension has the 'webRequest'
   // permission. For blocking calls we require the additional permission
   // 'webRequestBlocking'.
   if ((!is_guest && extra_info_spec &
@@ skipping 14 matching lines @@
   if (!is_guest && extensions::PermissionsData::GetEffectiveHostPermissions(
           extension).is_empty()) {
     error_ = keys::kHostPermissionsRequired;
     return false;
   }
 
   bool success =
       ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
           profile_id(), extension_id(), extension_name,
           event_name, sub_event_name, filter, extra_info_spec,
-          embedder_process_id, embedder_routing_id, webview_instance_id,
-          ipc_sender_weak());
+          embedder_process_id, webview_instance_id, ipc_sender_weak());
   EXTENSION_FUNCTION_VALIDATE(success);
 
   helpers::ClearCacheOnNavigation();
 
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
       &helpers::NotifyWebRequestAPIUsed,
       profile_id(), make_scoped_refptr(GetExtension())));
 
   return true;
 }
@@ skipping 159 matching lines @@
       } else if ((*it)->name().find("AdBlock") != std::string::npos) {
         adblock = true;
       } else {
         other = true;
       }
     }
   }
 
   host->Send(new ExtensionMsg_UsingWebRequestAPI(adblock, adblock_plus, other));
 }