RefCounted types should not have public destructors, webkit/

webkit/tools/test_shell/simple_resource_loader_bridge.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 file contains an implementation of the ResourceLoaderBridge class.
 // The class is implemented using net::URLRequest, meaning it is a "simple"
 // version that directly issues requests. The more complicated one used in the
 // browser uses IPC.
 //
 // Because net::URLRequest only provides an asynchronous resource loading API,
@@ skipping 91 matching lines @@
 };
 
 //-----------------------------------------------------------------------------
 
 bool g_accept_all_cookies = false;
 
 class TestShellNetworkDelegate : public net::NetworkDelegate {
  public:
   virtual ~TestShellNetworkDelegate() {}
 
- private:
+ protected:
   // net::NetworkDelegate implementation.
   virtual int OnBeforeURLRequest(net::URLRequest* request,
                                  const net::CompletionCallback& callback,
                                  GURL* new_url) OVERRIDE {
     return net::OK;
   }
   virtual int OnBeforeSendHeaders(net::URLRequest* request,
                                   const net::CompletionCallback& callback,
                                   net::HttpRequestHeaders* headers) OVERRIDE {
     return net::OK;
@@ skipping 65 matching lines @@
   std::string file_path_template;
   GURL http_prefix;
 };
 
 FileOverHTTPParams* g_file_over_http_params = NULL;
 
 //-----------------------------------------------------------------------------
 
 class IOThread : public base::Thread {
  public:
-  IOThread() : base::Thread("IOThread") {
-  }
+  IOThread() : base::Thread("IOThread") {}
 
   ~IOThread() {
     Stop();
   }
 
-  virtual void Init() {
+  virtual void Init() OVERRIDE {
     if (g_request_context_params) {
       g_request_context = new TestShellRequestContext(
           g_request_context_params->cache_path,
           g_request_context_params->cache_mode,
           g_request_context_params->no_proxy);
       delete g_request_context_params;
       g_request_context_params = NULL;
     } else {
       g_request_context = new TestShellRequestContext();
     }
 
     g_request_context->AddRef();
 
     g_network_delegate = new TestShellNetworkDelegate();
     g_request_context->set_network_delegate(g_network_delegate);
 
     SimpleAppCacheSystem::InitializeOnIOThread(g_request_context);
     SimpleSocketStreamBridge::InitializeOnIOThread(g_request_context);
     SimpleFileWriter::InitializeOnIOThread(g_request_context);
     SimpleFileSystem::InitializeOnIOThread(
         g_request_context->blob_storage_controller());
     TestShellWebBlobRegistryImpl::InitializeOnIOThread(
         g_request_context->blob_storage_controller());
   }
 
-  virtual void CleanUp() {
+  virtual void CleanUp() OVERRIDE {
     // In reverse order of initialization.
     TestShellWebBlobRegistryImpl::Cleanup();
     SimpleFileSystem::CleanupOnIOThread();
     SimpleFileWriter::CleanupOnIOThread();
     SimpleSocketStreamBridge::Cleanup();
     SimpleAppCacheSystem::CleanupOnIOThread();
 
     if (g_request_context) {
       g_request_context->set_network_delegate(NULL);
       g_request_context->Release();
@@ skipping 530 matching lines @@
  public:
   explicit SyncRequestProxy(ResourceLoaderBridge::SyncLoadResponse* result)
       : result_(result), event_(true, false) {
   }
 
   void WaitForCompletion() {
     event_.Wait();
   }
 
   // --------------------------------------------------------------------------
-  // Event hooks that run on the IO thread:
+  // RequestProxy event hooks that run on the IO thread:
 
   virtual void OnReceivedRedirect(
       const GURL& new_url,
       const ResourceResponseInfo& info,
-      bool* defer_redirect) {
+      bool* defer_redirect) OVERRIDE {
     // TODO(darin): It would be much better if this could live in WebCore, but
     // doing so requires API changes at all levels.  Similar code exists in
     // WebCore/platform/network/cf/ResourceHandleCFNet.cpp :-(
     if (new_url.GetOrigin() != result_->url.GetOrigin()) {
       DLOG(WARNING) << "Cross origin redirect denied";
       Cancel();
       return;
     }
     result_->url = new_url;
   }
 
-  virtual void OnReceivedResponse(const ResourceResponseInfo& info) {
+  virtual void OnReceivedResponse(const ResourceResponseInfo& info) OVERRIDE {
     *static_cast<ResourceResponseInfo*>(result_) = info;
   }
 
-  virtual void OnReceivedData(int bytes_read) {
+  virtual void OnReceivedData(int bytes_read) OVERRIDE {
     if (download_to_file_)
       file_stream_.WriteSync(buf_->data(), bytes_read);
     else
       result_->data.append(buf_->data(), bytes_read);
     AsyncReadData();  // read more (may recurse)
   }
 
-  virtual void OnCompletedRequest(const net::URLRequestStatus& status,
-                                  const std::string& security_info,
-                                  const base::TimeTicks& complete_time) {
+  virtual void OnCompletedRequest(
+      const net::URLRequestStatus& status,
+      const std::string& security_info,
+      const base::TimeTicks& complete_time) OVERRIDE {
     if (download_to_file_)
       file_stream_.CloseSync();
     result_->status = status;
     event_.Signal();
   }
 
+ protected:
+  virtual ~SyncRequestProxy() {}
+
  private:
   ResourceLoaderBridge::SyncLoadResponse* result_;
   base::WaitableEvent event_;
 };
 
 //-----------------------------------------------------------------------------
 
 class ResourceLoaderBridgeImpl : public ResourceLoaderBridge {
  public:
   ResourceLoaderBridgeImpl(
@@ skipping 112 matching lines @@
  public:
   void Set(const GURL& url, const std::string& cookie) {
     DCHECK(MessageLoop::current() == g_io_thread->message_loop());
     g_request_context->cookie_store()->SetCookieWithOptionsAsync(
         url, cookie, net::CookieOptions(),
         net::CookieStore::SetCookiesCallback());
   }
 
  private:
   friend class base::RefCountedThreadSafe<CookieSetter>;
-
   ~CookieSetter() {}
 };
 
 class CookieGetter : public base::RefCountedThreadSafe<CookieGetter> {
  public:
   CookieGetter() : event_(false, false) {
   }
 
   void Get(const GURL& url) {
     g_request_context->cookie_store()->GetCookiesWithOptionsAsync(
         url, net::CookieOptions(),
         base::Bind(&CookieGetter::OnGetCookies, this));
   }
 
   std::string GetResult() {
     event_.Wait();
     return result_;
   }
 
  private:
+  friend class base::RefCountedThreadSafe<CookieGetter>;
+  ~CookieGetter() {}
+
   void OnGetCookies(const std::string& cookie_line) {
     result_ = cookie_line;
     event_.Signal();
   }
-  friend class base::RefCountedThreadSafe<CookieGetter>;
-
-  ~CookieGetter() {}
 
   base::WaitableEvent event_;
   std::string result_;
 };
 
 }  // anonymous namespace
 
 //-----------------------------------------------------------------------------
 
 // static
@@ skipping 125 matching lines @@
          (http_prefix.SchemeIs("http") || http_prefix.SchemeIs("https")));
   g_file_over_http_params = new FileOverHTTPParams(file_path_template,
                                                    http_prefix);
 }
 
 // static
 webkit_glue::ResourceLoaderBridge* SimpleResourceLoaderBridge::Create(
     const webkit_glue::ResourceLoaderBridge::RequestInfo& request_info) {
   return new ResourceLoaderBridgeImpl(request_info);
 }