RefCounted types should not have public destructors, net/

net/cookies/cookie_monster_unittest.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/cookies/cookie_store_unittest.h"
 
 #include <time.h>
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 27 matching lines @@
  public:
   MOCK_METHOD1(Load, void(const LoadedCallback& loaded_callback));
   MOCK_METHOD2(LoadCookiesForKey, void(const std::string& key,
                                        const LoadedCallback& loaded_callback));
   MOCK_METHOD1(AddCookie, void(const CookieMonster::CanonicalCookie& cc));
   MOCK_METHOD1(UpdateCookieAccessTime,
                void(const CookieMonster::CanonicalCookie& cc));
   MOCK_METHOD1(DeleteCookie, void(const CookieMonster::CanonicalCookie& cc));
   MOCK_METHOD1(SetClearLocalStateOnExit, void(bool clear_local_state));
   MOCK_METHOD1(Flush, void(const base::Closure& callback));
+
+ private:
+  virtual ~NewMockPersistentCookieStore() {}
 };
 
 const char* kTopLevelDomainPlus1 = "http://www.harvard.edu";
 const char* kTopLevelDomainPlus2 = "http://www.math.harvard.edu";
 const char* kTopLevelDomainPlus2Secure = "https://www.math.harvard.edu";
 const char* kTopLevelDomainPlus3 =
     "http://www.bourbaki.math.harvard.edu";
 const char* kOtherDomain = "http://www.mit.edu";
 const char kUrlGoogleSpecific[] = "http://www.gmail.google.izzle";
 
@@ skipping 2137 matching lines @@
     ++flush_count_;
     if (!callback.is_null())
       callback.Run();
   }
 
   int flush_count() {
     return flush_count_;
   }
 
  private:
+  virtual ~FlushablePersistentStore() {}
+
   volatile int flush_count_;
 };
 
 // Counts the number of times Callback() has been run.
 class CallbackCounter : public base::RefCountedThreadSafe<CallbackCounter> {
  public:
   CallbackCounter() : callback_count_(0) {}
 
   void Callback() {
     ++callback_count_;
   }
 
   int callback_count() {
     return callback_count_;
   }
 
  private:
   friend class base::RefCountedThreadSafe<CallbackCounter>;
+  ~CallbackCounter() {}
+
   volatile int callback_count_;
 };
 
 }  // namespace
 
 // Test that FlushStore() is forwarded to the store and callbacks are posted.
 TEST_F(CookieMonsterTest, FlushStore) {
   scoped_refptr<CallbackCounter> counter(new CallbackCounter());
   scoped_refptr<FlushablePersistentStore> store(new FlushablePersistentStore());
   scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL));
@@ skipping 445 matching lines @@
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[4].type);
 
   // Create some non-persistent cookies and check that they don't go to the
   // persistent storage.
   EXPECT_TRUE(SetCookie(cm, url_google_, "B=Bar"));
   this->MatchCookieLines("A=Foo; B=Bar", GetCookies(cm, url_google_));
   EXPECT_EQ(5u, store->commands().size());
 }
 
 }  // namespace net