Linux: fix a data race in a proxy config service unit test.

net/proxy/proxy_config_service_linux.h

 // Copyright (c) 2009 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 NET_PROXY_PROXY_CONFIG_SERVICE_LINUX_H_
 #define NET_PROXY_PROXY_CONFIG_SERVICE_LINUX_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 15 matching lines @@
 
   // Forward declaration of Delegate.
   class Delegate;
 
   class GConfSettingGetter {
    public:
     // Buffer size used in some implementations of this class when reading
     // files. Defined here so unit tests can construct worst-case inputs.
     static const size_t BUFFER_SIZE = 512;
 
+    GConfSettingGetter() {}
     virtual ~GConfSettingGetter() {}
 
     // Initializes the class: obtains a gconf client, or simulates one, in
     // the concrete implementations. Returns true on success. Must be called
     // before using other methods, and should be called on the thread running
     // the glib main loop.
     // One of |glib_default_loop| and |file_loop| will be used for gconf calls
     // or reading necessary files, depending on the implementation.
     virtual bool Init(MessageLoop* glib_default_loop,
                       MessageLoopForIO* file_loop) = 0;
@@ skipping 21 matching lines @@
     // after a failed call to SetupNotification() or after calling
     // Release().
     virtual bool GetString(const char* key, std::string* result) = 0;
     // Same thing for a bool typed value.
     virtual bool GetBoolean(const char* key, bool* result) = 0;
     // Same for an int typed value.
     virtual bool GetInt(const char* key, int* result) = 0;
     // And for a string list.
     virtual bool GetStringList(const char* key,
                                std::vector<std::string>* result) = 0;
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(GConfSettingGetter);
   };
 
   // ProxyConfigServiceLinux is created on the UI thread, and
   // SetupAndFetchInitialConfig() is immediately called to
   // synchronously fetch the original configuration and setup gconf
   // notifications on the UI thread.
   //
   // Passed that point, it is accessed periodically through
   // GetProxyConfig() from the IO thread.
   //
@@ skipping 23 matching lines @@
     // used, also enables gconf notification for setting
     // changes. gconf must only be accessed from the thread running
     // the default glib main loop, and so this method must be called
     // from the UI thread. The message loop for the IO thread is
     // specified so that notifications can post tasks to it (and for
     // assertions). The message loop for the file thread is used to
     // read any files needed to determine proxy settings.
     void SetupAndFetchInitialConfig(MessageLoop* glib_default_loop,
                                     MessageLoop* io_loop,
                                     MessageLoopForIO* file_loop);
-    // Resets cached_config_ and releases the gconf_getter_, making it
-    // possible to call SetupAndFetchInitialConfig() again. Only used
-    // in testing.
-    void Reset();
 
     // Handler for gconf change notifications: fetches a new proxy
     // configuration from gconf settings, and if this config is
     // different than what we had before, posts a task to have it
     // stored in cached_config_.
     // Left public for simplicity.
     void OnCheckProxyConfigSettings();
 
     // Called from IO thread.
     int GetProxyConfig(ProxyConfig* config);
@@ skipping 73 matching lines @@
   virtual ~ProxyConfigServiceLinux() {
     delegate_->PostDestroyTask();
   }
 
   void SetupAndFetchInitialConfig(MessageLoop* glib_default_loop,
                                   MessageLoop* io_loop,
                                   MessageLoopForIO* file_loop) {
     delegate_->SetupAndFetchInitialConfig(glib_default_loop, io_loop,
                                           file_loop);
   }
-  void Reset() {
-    delegate_->Reset();
-  }
   void OnCheckProxyConfigSettings() {
     delegate_->OnCheckProxyConfigSettings();
   }
 
   // ProxyConfigService methods:
   // Called from IO thread.
   virtual int GetProxyConfig(ProxyConfig* config) {
     return delegate_->GetProxyConfig(config);
   }
 
  private:
   scoped_refptr<Delegate> delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(ProxyConfigServiceLinux);
 };
 
 }  // namespace net
 
 #endif  // NET_PROXY_PROXY_CONFIG_SERVICE_LINUX_H_