Second patch in making destructors of refcounted objects private.

net/url_request/url_request_unittest.h

 // Copyright (c) 2006-2008 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_URL_REQUEST_URL_REQUEST_UNITTEST_H_
 #define NET_URL_REQUEST_URL_REQUEST_UNITTEST_H_
 
 #include <stdlib.h>
 
 #include <sstream>
@@ skipping 45 matching lines @@
     host_resolver_ = net::CreateSystemHostResolver();
     net::ProxyConfig proxy_config;
     proxy_config.proxy_rules.ParseFromString(proxy);
     proxy_service_ = net::ProxyService::CreateFixed(proxy_config);
     ssl_config_service_ = new net::SSLConfigServiceDefaults;
     http_transaction_factory_ =
         net::HttpNetworkLayer::CreateFactory(host_resolver_,
             proxy_service_, ssl_config_service_);
   }
 
-  virtual ~TestURLRequestContext() {
+ protected:
+  ~TestURLRequestContext() {
     delete http_transaction_factory_;
   }
 };
 
 class TestDelegate : public URLRequest::Delegate {
  public:
   TestDelegate()
       : cancel_in_rr_(false),
         cancel_in_rs_(false),
         cancel_in_rd_(false),
@@ skipping 160 matching lines @@
 
 // This object bounds the lifetime of an external python-based HTTP/FTP server
 // that can provide various responses useful for testing.
 class BaseTestServer : public base::RefCounted<BaseTestServer> {
  protected:
   BaseTestServer() { }
   BaseTestServer(int connection_attempts, int connection_timeout)
       : launcher_(connection_attempts, connection_timeout) { }
 
  public:
-  virtual ~BaseTestServer() { }
-
   void set_forking(bool forking) {
     launcher_.set_forking(forking);
   }
 
   // Used with e.g. HTTPTestServer::SendQuit()
   bool WaitToFinish(int milliseconds) {
     return launcher_.WaitToFinish(milliseconds);
   }
 
   bool Stop() {
@@ skipping 29 matching lines @@
     return TestServerPage(WideToUTF8(path));
   }
 
   virtual bool MakeGETRequest(const std::string& page_name) = 0;
 
   FilePath GetDataDirectory() {
     return launcher_.GetDocumentRootPath();
   }
 
  protected:
+  friend class base::RefCounted<BaseTestServer>;
+  virtual ~BaseTestServer() { }
+
   bool Start(net::TestServerLauncher::Protocol protocol,
              const std::string& host_name, int port,
              const FilePath& document_root,
              const FilePath& cert_path,
              const std::wstring& file_root_url) {
     if (!launcher_.Start(protocol,
         host_name, port, document_root, cert_path, file_root_url))
       return false;
 
     if (protocol == net::TestServerLauncher::ProtoFTP)
@@ skipping 41 matching lines @@
 // HTTP
 class HTTPTestServer : public BaseTestServer {
  protected:
   explicit HTTPTestServer() : loop_(NULL) {
   }
 
   explicit HTTPTestServer(int connection_attempts, int connection_timeout)
       : BaseTestServer(connection_attempts, connection_timeout), loop_(NULL) {
   }
 
+  virtual ~HTTPTestServer() {}
+
  public:
   // Creates and returns a new HTTPTestServer. If |loop| is non-null, requests
   // are serviced on it, otherwise a new thread and message loop are created.
   static scoped_refptr<HTTPTestServer> CreateServer(
       const std::wstring& document_root,
       MessageLoop* loop) {
     return CreateServerWithFileRootURL(document_root, std::wstring(), loop);
   }
 
   static scoped_refptr<HTTPTestServer> CreateServer(
@@ skipping 184 matching lines @@
     scoped_refptr<HTTPSTestServer> test_server = new HTTPSTestServer();
     FilePath docroot = FilePath::FromWStringHack(document_root);
     FilePath certpath = FilePath::FromWStringHack(cert_path);
     if (!test_server->Start(net::TestServerLauncher::ProtoHTTP,
         host_name, port, docroot, certpath, std::wstring())) {
       return NULL;
     }
     return test_server;
   }
 
-  virtual ~HTTPSTestServer() {
-  }
-
  protected:
   std::wstring cert_path_;
+
+ private:
+  virtual ~HTTPSTestServer() {}
 };
 
 
 class FTPTestServer : public BaseTestServer {
  public:
   FTPTestServer() {
   }
 
   static scoped_refptr<FTPTestServer> CreateServer(
       const std::wstring& document_root) {
@@ skipping 15 matching lines @@
     request.set_method("GET");
     request.Start();
     EXPECT_TRUE(request.is_pending());
 
     MessageLoop::current()->Run();
     if (request.is_pending())
       return false;
 
     return true;
   }
+
+ private:
+  ~FTPTestServer() {}
 };
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_UNITTEST_H_