Revert of Fix WebRequest's EventListener::operator<

extensions/browser/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 "extensions/browser/api/web_request/web_request_api.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 379 matching lines @@
   std::string sub_event_name;
   RequestFilter filter;
   int extra_info_spec;
   int embedder_process_id;
   int web_view_instance_id;
   base::WeakPtr<IPC::Sender> ipc_sender;
   mutable std::set<uint64_t> blocked_requests;
 
   // Comparator to work with std::set.
   bool operator<(const EventListener& that) const {
-    return std::tie(extension_id, sub_event_name, web_view_instance_id,
-                    embedder_process_id) <
-           std::tie(that.extension_id, that.sub_event_name,
-                    that.web_view_instance_id, that.embedder_process_id);
+    if (extension_id != that.extension_id)
+      return extension_id < that.extension_id;
+
+    if (sub_event_name != that.sub_event_name)
+      return sub_event_name < that.sub_event_name;
+
+    if (web_view_instance_id != that.web_view_instance_id)
+      return web_view_instance_id < that.web_view_instance_id;
+
+    if (web_view_instance_id == 0) {
+      // Do not filter by process ID for non-webviews, because this comparator
+      // is also used to find and remove an event listener when an extension is
+      // unloaded. At this point, the event listener cannot be mapped back to
+      // the original process, so 0 is used instead of the actual process ID.
+      if (embedder_process_id == 0 || that.embedder_process_id == 0)
+        return false;
+    }
+
+    if (embedder_process_id != that.embedder_process_id)
+      return embedder_process_id < that.embedder_process_id;
+
+    return false;
   }
 
   EventListener()
       : histogram_value(events::UNKNOWN),
         extra_info_spec(0),
         embedder_process_id(0),
         web_view_instance_id(0) {}
 };
 
 // Contains info about requests that are blocked waiting for a response from
@@ skipping 708 matching lines @@
   }
 
   if (ContainsKey(listeners_[browser_context][event_name], listener)) {
     // This is likely an abuse of the API by a malicious extension.
     return false;
   }
   listeners_[browser_context][event_name].insert(listener);
   return true;
 }
 
-int ExtensionWebRequestEventRouter::GetListenerCountForTesting(
-    void* browser_context,
-    const std::string& event_name) {
-  return listeners_[browser_context][event_name].size();
-}
-
 void ExtensionWebRequestEventRouter::RemoveEventListener(
     void* browser_context,
     const std::string& extension_id,
     const std::string& sub_event_name,
     int embedder_process_id,
     int web_view_instance_id) {
   std::string event_name = EventRouter::GetBaseEventName(sub_event_name);
   DCHECK(IsWebRequestEvent(event_name));
 
-  std::set<EventListener>& event_listeners =
-      listeners_[browser_context][event_name];
-
   EventListener listener;
   listener.extension_id = extension_id;
   listener.sub_event_name = sub_event_name;
+  listener.embedder_process_id = embedder_process_id;
+  listener.web_view_instance_id = web_view_instance_id;
 
-  if (web_view_instance_id != 0) {
-    listener.embedder_process_id = embedder_process_id;
-    listener.web_view_instance_id = web_view_instance_id;
-  } else {
-    for (const EventListener& l : event_listeners) {
-      if (l.extension_id == extension_id && l.sub_event_name == sub_event_name)
-        listener.embedder_process_id = l.embedder_process_id;
-    }
-  }
-
+  std::set<EventListener>& event_listeners =
+      listeners_[browser_context][event_name];
   // It's possible for AddEventListener to fail asynchronously. In that case,
   // the renderer believes the listener exists, while the browser does not.
   // Ignore a RemoveEventListener in that case.
   std::set<EventListener>::const_iterator it = event_listeners.find(listener);
   if (it == event_listeners.end())
     return;
 
+#if defined(OS_WIN)
+  // Debugging https://crbug.com/589735
+  // Please post crash reports at the following lines to the above issue.
+  unsigned event_listener_count = event_listeners.count(listener);
+  CHECK_GE(event_listener_count, 0u);
+  CHECK_GE(event_listener_count, 1u);
+  CHECK_LE(event_listener_count, 2u);
+  CHECK_EQ(event_listener_count, 1u);
+  CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+#endif  // OS_WIN
   CHECK_EQ(event_listeners.count(listener), 1u) <<
       "extension=" << extension_id << " event=" << event_name;
 
   // Unblock any request that this event listener may have been blocking.
   for (uint64_t id : it->blocked_requests)
     DecrementBlockCount(browser_context, extension_id, event_name, id, NULL);
 
   event_listeners.erase(listener);
 
   helpers::ClearCacheOnNavigation();
@@ skipping 1071 matching lines @@
   // Continue gracefully.
   RunSync();
 }
 
 bool WebRequestHandlerBehaviorChangedFunction::RunSync() {
   helpers::ClearCacheOnNavigation();
   return true;
 }
 
 }  // namespace extensions