RefCounted types should not have public destructors, chrome/browser/ part 6

chrome/browser/custom_handlers/protocol_handler_registry.h

 // Copyright (c) 2011 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_CUSTOM_HANDLERS_PROTOCOL_HANDLER_REGISTRY_H_
 #define CHROME_BROWSER_CUSTOM_HANDLERS_PROTOCOL_HANDLER_REGISTRY_H_
 #pragma once
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
+#include "base/sequenced_task_runner_helpers.h"
 #include "base/values.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/shell_integration.h"
 #include "chrome/common/custom_handlers/protocol_handler.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_job.h"
 
 // This is where handlers for protocols registered with
@@ skipping 52 matching lines @@
         const std::string& protocol,
         ProtocolHandlerRegistry* registry);
   };
 
   typedef std::map<std::string, ProtocolHandler> ProtocolHandlerMap;
   typedef std::vector<ProtocolHandler> ProtocolHandlerList;
   typedef std::map<std::string, ProtocolHandlerList> ProtocolHandlerMultiMap;
   typedef std::vector<DefaultClientObserver*> DefaultClientObserverList;
 
   ProtocolHandlerRegistry(Profile* profile, Delegate* delegate);
-  ~ProtocolHandlerRegistry();
 
   // Called when a site tries to register as a protocol handler. If the request
   // can be handled silently by the registry - either to ignore the request
   // or to update an existing handler - the request will succeed. If this
   // function returns false the user needs to be prompted for confirmation.
   bool SilentlyHandleRegisterHandlerRequest(const ProtocolHandler& handler);
 
   // Called when the user accepts the registration of a given protocol handler.
   void OnAcceptRegisterProtocolHandler(const ProtocolHandler& handler);
 
@@ skipping 87 matching lines @@
   // This is called by the UI thread when the system is shutting down. This
   // does finalization which must be done on the UI thread.
   void Finalize();
 
   // Registers the preferences that we store registered protocol handlers in.
   static void RegisterPrefs(PrefService* prefService);
 
   bool enabled() const { return enabled_; }
 
  private:
-  friend class base::RefCountedThreadSafe<ProtocolHandlerRegistry>;
+  friend class base::DeleteHelper<ProtocolHandlerRegistry>;
+  friend struct content::BrowserThread::DeleteOnThread<
+      content::BrowserThread::IO>;
+  friend class ProtocolHandlerRegistryTest;
+  friend class RegisterProtocolHandlerBrowserTest;
+
+  ~ProtocolHandlerRegistry();
 
   // Puts the given handler at the top of the list of handlers for its
   // protocol.
   void PromoteHandler(const ProtocolHandler& handler);
 
   // Clears the default for the provided protocol.
   // Should be called only from the IO thread.
   void ClearDefaultIO(const std::string& scheme);
 
   // Makes this ProtocolHandler the default handler for its protocol.
@@ skipping 36 matching lines @@
   void RegisterProtocolHandler(const ProtocolHandler& handler);
 
   // Get the DictionaryValues stored under the given pref name that are valid
   // ProtocolHandler values.
   std::vector<const DictionaryValue*> GetHandlersFromPref(
       const char* pref_name) const;
 
   // Ignores future requests to register the given protocol handler.
   void IgnoreProtocolHandler(const ProtocolHandler& handler);
 
-  // Register
-  void IgnoreHandlerFromValue(const DictionaryValue* value);
-
   // Map from protocols (strings) to protocol handlers.
   ProtocolHandlerMultiMap protocol_handlers_;
 
   // Protocol handlers that the user has told us to ignore.
   ProtocolHandlerList ignored_protocol_handlers_;
 
   // Protocol handlers that are the defaults for a given protocol.
   ProtocolHandlerMap default_handlers_;
 
   // The Profile that owns this ProtocolHandlerRegistry.
@@ skipping 10 matching lines @@
   bool enabled_io_;
 
   // Whether or not we are loading.
   bool is_loading_;
 
   DefaultClientObserverList default_client_observers_;
 
   // Copy of default_handlers_ that is only accessed on the IO thread.
   ProtocolHandlerMap default_handlers_io_;
 
-  friend class ProtocolHandlerRegistryTest;
-  friend class RegisterProtocolHandlerBrowserTest;
-
   DISALLOW_COPY_AND_ASSIGN(ProtocolHandlerRegistry);
 };
 #endif  // CHROME_BROWSER_CUSTOM_HANDLERS_PROTOCOL_HANDLER_REGISTRY_H_