Template methods on Timer classes instead of the classes themselves.

net/proxy/proxy_config_service_linux.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 "net/proxy/proxy_config_service_linux.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #if defined(USE_GCONF)
 #include <gconf/gconf-client.h>
@@ skipping 190 matching lines @@
 
 #if defined(USE_GCONF)
 // This setting getter uses gconf, as used in GNOME 2 and some GNOME 3 desktops.
 class SettingGetterImplGConf : public ProxyConfigServiceLinux::SettingGetter {
  public:
   SettingGetterImplGConf()
       : client_(NULL),
         system_proxy_id_(0),
         system_http_proxy_id_(0),
         notify_delegate_(NULL),
-        debounce_timer_(new base::OneShotTimer<SettingGetterImplGConf>()) {
-  }
+        debounce_timer_(new base::OneShotTimer()) {}
 
   ~SettingGetterImplGConf() override {
     // client_ should have been released before now, from
     // Delegate::OnDestroy(), while running on the UI thread. However
     // on exiting the process, it may happen that Delegate::OnDestroy()
     // task is left pending on the glib loop after the loop was quit,
     // and pending tasks may then be deleted without being run.
     if (client_) {
       // gconf client was not cleaned up.
       if (task_runner_->BelongsToCurrentThread()) {
@@ skipping 275 matching lines @@
     setting_getter->OnChangeNotification();
   }
 
   GConfClient* client_;
   // These ids are the values returned from gconf_client_notify_add(), which we
   // will need in order to later call gconf_client_notify_remove().
   guint system_proxy_id_;
   guint system_http_proxy_id_;
 
   ProxyConfigServiceLinux::Delegate* notify_delegate_;
-  scoped_ptr<base::OneShotTimer<SettingGetterImplGConf> > debounce_timer_;
+  scoped_ptr<base::OneShotTimer> debounce_timer_;
 
   // Task runner for the thread that we make gconf calls on. It should
   // be the UI thread and all our methods should be called on this
   // thread. Only for assertions.
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(SettingGetterImplGConf);
 };
 #endif  // defined(USE_GCONF)
 
 #if defined(USE_GIO)
 const char kProxyGConfSchema[] = "org.gnome.system.proxy";
 
 // This setting getter uses gsettings, as used in most GNOME 3 desktops.
 class SettingGetterImplGSettings
     : public ProxyConfigServiceLinux::SettingGetter {
  public:
-  SettingGetterImplGSettings() :
-    client_(NULL),
-    http_client_(NULL),
-    https_client_(NULL),
-    ftp_client_(NULL),
-    socks_client_(NULL),
-    notify_delegate_(NULL),
-    debounce_timer_(new base::OneShotTimer<SettingGetterImplGSettings>()) {
-  }
+  SettingGetterImplGSettings()
+      : client_(NULL),
+        http_client_(NULL),
+        https_client_(NULL),
+        ftp_client_(NULL),
+        socks_client_(NULL),
+        notify_delegate_(NULL),
+        debounce_timer_(new base::OneShotTimer()) {}
 
   ~SettingGetterImplGSettings() override {
     // client_ should have been released before now, from
     // Delegate::OnDestroy(), while running on the UI thread. However
     // on exiting the process, it may happen that
     // Delegate::OnDestroy() task is left pending on the glib loop
     // after the loop was quit, and pending tasks may then be deleted
     // without being run.
     if (client_) {
       // gconf client was not cleaned up.
@@ skipping 224 matching lines @@
         reinterpret_cast<SettingGetterImplGSettings*>(user_data);
     setting_getter->OnChangeNotification();
   }
 
   GSettings* client_;
   GSettings* http_client_;
   GSettings* https_client_;
   GSettings* ftp_client_;
   GSettings* socks_client_;
   ProxyConfigServiceLinux::Delegate* notify_delegate_;
-  scoped_ptr<base::OneShotTimer<SettingGetterImplGSettings> > debounce_timer_;
+  scoped_ptr<base::OneShotTimer> debounce_timer_;
 
   // Task runner for the thread that we make gsettings calls on. It should
   // be the UI thread and all our methods should be called on this
   // thread. Only for assertions.
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   LibGioLoader libgio_loader_;
 
   DISALLOW_COPY_AND_ASSIGN(SettingGetterImplGSettings);
 };
@@ skipping 65 matching lines @@
 
 // This is the KDE version that reads kioslaverc and simulates gconf.
 // Doing this allows the main Delegate code, as well as the unit tests
 // for it, to stay the same - and the settings map fairly well besides.
 class SettingGetterImplKDE : public ProxyConfigServiceLinux::SettingGetter,
                              public base::MessagePumpLibevent::Watcher {
  public:
   explicit SettingGetterImplKDE(base::Environment* env_var_getter)
       : inotify_fd_(-1),
         notify_delegate_(NULL),
-        debounce_timer_(new base::OneShotTimer<SettingGetterImplKDE>()),
+        debounce_timer_(new base::OneShotTimer()),
         indirect_manual_(false),
         auto_no_pac_(false),
         reversed_bypass_list_(false),
         env_var_getter_(env_var_getter),
         file_task_runner_(NULL) {
     // This has to be called on the UI thread (http://crbug.com/69057).
     base::ThreadRestrictions::ScopedAllowIO allow_io;
 
     // Derive the location of the kde config dir from the environment.
     std::string home;
@@ skipping 450 matching lines @@
     }
   }
 
   typedef std::map<StringSetting, std::string> string_map_type;
   typedef std::map<StringListSetting,
                    std::vector<std::string> > strings_map_type;
 
   int inotify_fd_;
   base::MessagePumpLibevent::FileDescriptorWatcher inotify_watcher_;
   ProxyConfigServiceLinux::Delegate* notify_delegate_;
-  scoped_ptr<base::OneShotTimer<SettingGetterImplKDE> > debounce_timer_;
+  scoped_ptr<base::OneShotTimer> debounce_timer_;
   base::FilePath kde_config_dir_;
   bool indirect_manual_;
   bool auto_no_pac_;
   bool reversed_bypass_list_;
   // We don't own |env_var_getter_|.  It's safe to hold a pointer to it, since
   // both it and us are owned by ProxyConfigServiceLinux::Delegate, and have the
   // same lifetime.
   base::Environment* env_var_getter_;
 
   // We cache these settings whenever we re-read the kioslaverc file.
@@ skipping 427 matching lines @@
 void ProxyConfigServiceLinux::RemoveObserver(Observer* observer) {
   delegate_->RemoveObserver(observer);
 }
 
 ProxyConfigService::ConfigAvailability
     ProxyConfigServiceLinux::GetLatestProxyConfig(ProxyConfig* config) {
   return delegate_->GetLatestProxyConfig(config);
 }
 
 }  // namespace net