Extensions: Make ExtensionWebRequestEventRouter leaky.

extensions/browser/api/web_request/web_request_api.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.
 
 #ifndef EXTENSIONS_BROWSER_API_WEB_REQUEST_WEB_REQUEST_API_H_
 #define EXTENSIONS_BROWSER_API_WEB_REQUEST_WEB_REQUEST_API_H_
 
 #include <stdint.h>
 
 #include <list>
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
-#include "base/memory/singleton.h"
-#include "base/memory/weak_ptr.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "extensions/browser/api/declarative/rules_registry.h"
 #include "extensions/browser/api/declarative_webrequest/request_stage.h"
 #include "extensions/browser/api/web_request/web_request_api_helpers.h"
 #include "extensions/browser/api/web_request/web_request_permissions.h"
 #include "extensions/browser/browser_context_keyed_api_factory.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_function.h"
 #include "extensions/common/url_pattern_set.h"
@@ skipping 56 matching lines @@
   static const bool kServiceIsNULLWhileTesting = true;
 
   content::BrowserContext* browser_context_;
 
   DISALLOW_COPY_AND_ASSIGN(WebRequestAPI);
 };
 
 // This class observes network events and routes them to the appropriate
 // extensions listening to those events. All methods must be called on the IO
 // thread unless otherwise specified.
-class ExtensionWebRequestEventRouter
-    : public base::SupportsWeakPtr<ExtensionWebRequestEventRouter> {
+class ExtensionWebRequestEventRouter {
  public:
   struct BlockedRequest;
 
   enum EventTypes {
     kInvalidEvent = 0,
     kOnBeforeRequest = 1 << 0,
     kOnBeforeSendHeaders = 1 << 1,
     kOnSendHeaders = 1 << 2,
     kOnHeadersReceived = 1 << 3,
     kOnBeforeRedirect = 1 << 4,
@@ skipping 255 matching lines @@
     events::HistogramValue histogram_value = events::UNKNOWN;
     RequestFilter filter;
     int extra_info_spec = 0;
     base::WeakPtr<IPC::Sender> ipc_sender;
     std::unordered_set<uint64_t> blocked_requests;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(EventListener);
   };
 
-  friend struct base::DefaultSingletonTraits<ExtensionWebRequestEventRouter>;
-
   using RawListeners = std::vector<EventListener*>;
   using ListenerIDs = std::vector<EventListener::ID>;
   using Listeners = std::vector<std::unique_ptr<EventListener>>;
   using ListenerMapForBrowserContext = std::map<std::string, Listeners>;
   using ListenerMap = std::map<void*, ListenerMapForBrowserContext>;
   using BlockedRequestMap = std::map<uint64_t, BlockedRequest>;
   // Map of request_id -> bit vector of EventTypes already signaled
   using SignaledRequestMap = std::map<uint64_t, int>;
   // For each browser_context: a bool indicating whether it is an incognito
   // browser_context, and a pointer to the corresponding (non-)incognito
   // browser_context.
   using CrossBrowserContextMap = std::map<void*, std::pair<bool, void*>>;
   using CallbacksForPageLoad = std::list<base::Closure>;
 
   ExtensionWebRequestEventRouter();
-  ~ExtensionWebRequestEventRouter();
+
+  // This instance is leaked.
+  ~ExtensionWebRequestEventRouter() = delete;
 
   // Returns the EventListener with the given |id|, or nullptr. Must be called
   // from the IO thread.
   EventListener* FindEventListener(const EventListener::ID& id);
 
   // Returns the EventListener with the given |id| from |listeners|.
   EventListener* FindEventListenerInContainer(const EventListener::ID& id,
                                               Listeners& listeners);
 
   // Removes the listener for the given sub-event. Must be called from the IO
@@ skipping 220 matching lines @@
       extensions::QuotaLimitHeuristics* heuristics) const override;
   // Handle quota exceeded gracefully: Only warn the user but still execute the
   // function.
   void OnQuotaExceeded(const std::string& error) override;
   ResponseAction Run() override;
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_API_WEB_REQUEST_WEB_REQUEST_API_H_