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

chrome/browser/safe_browsing/safe_browsing_blocking_page_test.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.
 //
 // This test creates a fake safebrowsing service, where we can inject
 // malware and phishing urls.  It then uses a real browser to go to
 // these urls, and sends "goback" or "proceed" commands and verifies
 // they work.
 
 #include "base/bind.h"
@@ skipping 19 matching lines @@
 using content::BrowserThread;
 using content::InterstitialPage;
 using content::NavigationController;
 using content::WebContents;
 
 // A SafeBrowingService class that allows us to inject the malicious URLs.
 class FakeSafeBrowsingService :  public SafeBrowsingService {
  public:
   FakeSafeBrowsingService() {}
 
-  virtual ~FakeSafeBrowsingService() {}
-
   // Called on the IO thread to check if the given url is safe or not.  If we
   // can synchronously determine that the url is safe, CheckUrl returns true.
   // Otherwise it returns false, and "client" is called asynchronously with the
   // result when it is ready.
   // Overrides SafeBrowsingService::CheckBrowseUrl.
   virtual bool CheckBrowseUrl(const GURL& gurl, Client* client) {
     if (badurls[gurl.spec()] == SAFE)
       return true;
 
     BrowserThread::PostTask(
@@ skipping 30 matching lines @@
   }
 
   std::string GetReport() {
     EXPECT_TRUE(reports_.size() == 1);
     return reports_[0];
   }
 
   std::vector<std::string> reports_;
 
  private:
+  virtual ~FakeSafeBrowsingService() {}
+
   base::hash_map<std::string, UrlCheckResult> badurls;
 };
 
 // Factory that creates FakeSafeBrowsingService instances.
 class TestSafeBrowsingServiceFactory : public SafeBrowsingServiceFactory {
  public:
   TestSafeBrowsingServiceFactory() { }
   virtual ~TestSafeBrowsingServiceFactory() { }
 
   virtual SafeBrowsingService* CreateSafeBrowsingService() {
     return new FakeSafeBrowsingService();
   }
 };
 
 // A MalwareDetails class lets us intercept calls from the renderer.
 class FakeMalwareDetails : public MalwareDetails {
  public:
   FakeMalwareDetails(SafeBrowsingService* sb_service,
                      WebContents* web_contents,
                      const SafeBrowsingService::UnsafeResource& unsafe_resource)
       : MalwareDetails(sb_service, web_contents, unsafe_resource) { }
 
-  virtual ~FakeMalwareDetails() {}
-
   virtual void AddDOMDetails(
       const std::vector<SafeBrowsingHostMsg_MalwareDOMDetails_Node>& params) {
     EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     MalwareDetails::AddDOMDetails(params);
 
     // Notify the UI thread that we got the dom details.
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             base::Bind(&FakeMalwareDetails::OnDOMDetailsDone,
                                        this));
   }
@@ skipping 19 matching lines @@
 
   void set_waiting(bool waiting) {
     waiting_ = waiting;
   }
 
   safe_browsing::ClientMalwareReportRequest* get_report() {
     return report_.get();
   }
 
  private:
+  virtual ~FakeMalwareDetails() {}
+
   // Some logic to figure out if we should wait for the dom details or not.
   // These variables should only be accessed in the UI thread.
   bool got_dom_;
   bool waiting_;
 
 };
 
 class TestMalwareDetailsFactory : public MalwareDetailsFactory {
  public:
   TestMalwareDetailsFactory() { }
@@ skipping 435 matching lines @@
   SendCommand("\"proceed\"");  // Simulate the user clicking "back"
   AssertNoInterstitial(true);  // Assert the interstitial is gone
 
   EXPECT_EQ(
       url,
       browser()->GetSelectedTabContentsWrapper()->web_contents()->GetURL());
   AssertReportSent();
 }
 
 }  // namespace