RefCounted types should not have public destructors, chrome/browser/extensions

chrome/browser/extensions/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 CHROME_BROWSER_EXTENSIONS_API_WEB_REQUEST_WEB_REQUEST_API_H_
 #define CHROME_BROWSER_EXTENSIONS_API_WEB_REQUEST_WEB_REQUEST_API_H_
 #pragma once
 
 #include <list>
 #include <map>
@@ skipping 56 matching lines @@
     kOnBeforeRedirect = 1 << 4,
     kOnAuthRequired = 1 << 5,
     kOnResponseStarted = 1 << 6,
     kOnErrorOccurred = 1 << 7,
     kOnCompleted = 1 << 8,
   };
 
   // Internal representation of the webRequest.RequestFilter type, used to
   // filter what network events an extension cares about.
   struct RequestFilter {
-    URLPatternSet urls;
-    std::vector<ResourceType::Type> types;
-    int tab_id;
-    int window_id;
-
     RequestFilter();
     ~RequestFilter();
 
     // Returns false if there was an error initializing. If it is a user error,
     // an error message is provided, otherwise the error is internal (and
     // unexpected).
     bool InitFromValue(const base::DictionaryValue& value, std::string* error);
+
+    URLPatternSet urls;
+    std::vector<ResourceType::Type> types;
+    int tab_id;
+    int window_id;
   };
 
   // Internal representation of the extraInfoSpec parameter on webRequest
   // events, used to specify extra information to be included with network
   // events.
   struct ExtraInfoSpec {
     enum Flags {
       REQUEST_HEADERS = 1<<0,
       RESPONSE_HEADERS = 1<<1,
       BLOCKING = 1<<2,
       ASYNC_BLOCKING = 1<<3,
     };
 
     static bool InitFromValue(const base::ListValue& value,
                               int* extra_info_spec);
   };
 
   // Contains an extension's response to a blocking event.
   struct EventResponse {
+    EventResponse(const std::string& extension_id,
+                  const base::Time& extension_install_time);
+    ~EventResponse();
+
     // ID of the extension that sent this response.
     std::string extension_id;
 
     // The time that the extension was installed. Used for deciding order of
     // precedence in case multiple extensions respond with conflicting
     // decisions.
     base::Time extension_install_time;
 
     // Response values. These are mutually exclusive.
     bool cancel;
     GURL new_url;
     scoped_ptr<net::HttpRequestHeaders> request_headers;
     scoped_ptr<extension_web_request_api_helpers::ResponseHeaders>
         response_headers;
 
     scoped_ptr<net::AuthCredentials> auth_credentials;
 
-    EventResponse(const std::string& extension_id,
-                  const base::Time& extension_install_time);
-    ~EventResponse();
-
     DISALLOW_COPY_AND_ASSIGN(EventResponse);
   };
 
   static ExtensionWebRequestEventRouter* GetInstance();
 
   void RegisterRulesRegistry(
       scoped_refptr<extensions::WebRequestRulesRegistry> rules_registry);
 
   // Dispatches the OnBeforeRequest event to any extensions whose filters match
   // the given request. Returns net::ERR_IO_PENDING if an extension is
@@ skipping 112 matching lines @@
                            void* otr_profile);
   void OnOTRProfileDestroyed(void* original_profile,
                              void* otr_profile);
 
   // Registers a |callback| that is executed when the next page load happens.
   // The callback is then deleted.
   void AddCallbackForPageLoad(const base::Closure& callback);
 
  private:
   friend struct DefaultSingletonTraits<ExtensionWebRequestEventRouter>;
+
   struct EventListener;
   typedef std::map<std::string, std::set<EventListener> > ListenerMapForProfile;
   typedef std::map<void*, ListenerMapForProfile> ListenerMap;
   typedef std::map<uint64, BlockedRequest> BlockedRequestMap;
   // Map of request_id -> bit vector of EventTypes already signaled
   typedef std::map<uint64, int> SignaledRequestMap;
   typedef std::map<void*, void*> CrossProfileMap;
   typedef std::list<base::Closure> CallbacksForPageLoad;
 
   ExtensionWebRequestEventRouter();
@@ skipping 98 matching lines @@
 
   CallbacksForPageLoad callbacks_for_page_load_;
 
   scoped_refptr<extensions::WebRequestRulesRegistry> rules_registry_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionWebRequestEventRouter);
 };
 
 class WebRequestAddEventListener : public SyncIOThreadExtensionFunction {
  public:
+  DECLARE_EXTENSION_FUNCTION_NAME("webRequest.addEventListener");
+
+ protected:
+  virtual ~WebRequestAddEventListener() {}
+
+  // ExtensionFunction:
   virtual bool RunImpl() OVERRIDE;
-  DECLARE_EXTENSION_FUNCTION_NAME("webRequest.addEventListener");
 };
 
 class WebRequestEventHandled : public SyncIOThreadExtensionFunction {
  public:
+  DECLARE_EXTENSION_FUNCTION_NAME("webRequest.eventHandled");
+
+ protected:
+  virtual ~WebRequestEventHandled() {}
+
+  // ExtensionFunction:
   virtual bool RunImpl() OVERRIDE;
-  DECLARE_EXTENSION_FUNCTION_NAME("webRequest.eventHandled");
 };
 
 class WebRequestHandlerBehaviorChanged : public SyncIOThreadExtensionFunction {
  public:
-  virtual bool RunImpl() OVERRIDE;
-  DECLARE_EXTENSION_FUNCTION_NAME(
-      "webRequest.handlerBehaviorChanged");
+  DECLARE_EXTENSION_FUNCTION_NAME("webRequest.handlerBehaviorChanged");
 
- private:
+ protected:
+  virtual ~WebRequestHandlerBehaviorChanged() {}
+
+  // ExtensionFunction:
   virtual void GetQuotaLimitHeuristics(
       QuotaLimitHeuristics* heuristics) const OVERRIDE;
   // Handle quota exceeded gracefully: Only warn the user but still execute the
   // function.
   virtual void OnQuotaExceeded() OVERRIDE;
+  virtual bool RunImpl() OVERRIDE;
 };
 
 // Send updates to |host| with information about what webRequest-related
 // extensions are installed.
 // TODO(mpcomplete): remove. http://crbug.com/100411
 void SendExtensionWebRequestStatusToHost(content::RenderProcessHost* host);
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_WEB_REQUEST_WEB_REQUEST_API_H_