RefCounted types should not have public destructors, net/

net/websockets/websocket_job_spdy2_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/websockets/websocket_job.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 26 matching lines @@
 #include "testing/platform_test.h"
 
 using namespace net::test_spdy2;
 
 namespace {
 
 class MockSocketStream : public net::SocketStream {
  public:
   MockSocketStream(const GURL& url, net::SocketStream::Delegate* delegate)
       : SocketStream(url, delegate) {}
-  virtual ~MockSocketStream() {}
 
   virtual void Connect() OVERRIDE {}
   virtual bool SendData(const char* data, int len) OVERRIDE {
     sent_data_ += std::string(data, len);
     return true;
   }
 
   virtual void Close() OVERRIDE {}
   virtual void RestartWithAuth(
       const net::AuthCredentials& credentials) OVERRIDE {
   }
 
   virtual void DetachDelegate() OVERRIDE {
     delegate_ = NULL;
   }
 
   const std::string& sent_data() const {
     return sent_data_;
   }
 
+ protected:
+  virtual ~MockSocketStream() {}
+
  private:
   std::string sent_data_;
 };
 
 class MockSocketStreamDelegate : public net::SocketStream::Delegate {
  public:
   MockSocketStreamDelegate()
       : amount_sent_(0), allow_all_cookies_(true) {}
   void set_allow_all_cookies(bool allow_all_cookies) {
     allow_all_cookies_ = allow_all_cookies;
   }
   virtual ~MockSocketStreamDelegate() {}
 
   void SetOnStartOpenConnection(const base::Closure& callback) {
     on_start_open_connection_ = callback;
   }
   void SetOnConnected(const base::Closure& callback) {
     on_connected_ = callback;
   }
   void SetOnSentData(const base::Closure& callback) {
     on_sent_data_ = callback;
   }
   void SetOnReceivedData(const base::Closure& callback) {
     on_received_data_ = callback;
   }
   void SetOnClose(const base::Closure& callback) {
     on_close_ = callback;
   }
 
-  virtual int OnStartOpenConnection(net::SocketStream* socket,
-                                    const net::CompletionCallback& callback) {
+  virtual int OnStartOpenConnection(
+      net::SocketStream* socket,
+      const net::CompletionCallback& callback) OVERRIDE {
     if (!on_start_open_connection_.is_null())
       on_start_open_connection_.Run();
     return net::OK;
   }
   virtual void OnConnected(net::SocketStream* socket,
-                           int max_pending_send_allowed) {
+                           int max_pending_send_allowed) OVERRIDE {
     if (!on_connected_.is_null())
       on_connected_.Run();
   }
-  virtual void OnSentData(net::SocketStream* socket, int amount_sent) {
+  virtual void OnSentData(net::SocketStream* socket,
+                          int amount_sent) OVERRIDE {
     amount_sent_ += amount_sent;
     if (!on_sent_data_.is_null())
       on_sent_data_.Run();
   }
   virtual void OnReceivedData(net::SocketStream* socket,
-                              const char* data, int len) {
+                              const char* data, int len) OVERRIDE {
     received_data_ += std::string(data, len);
     if (!on_received_data_.is_null())
       on_received_data_.Run();
   }
   virtual void OnClose(net::SocketStream* socket) {
     if (!on_close_.is_null())
       on_close_.Run();
   }
-  virtual bool CanGetCookies(net::SocketStream* socket, const GURL& url) {
+  virtual bool CanGetCookies(net::SocketStream* socket,
+                             const GURL& url) OVERRIDE {
     return allow_all_cookies_;
   }
   virtual bool CanSetCookie(net::SocketStream* request,
                             const GURL& url,
                             const std::string& cookie_line,
-                            net::CookieOptions* options) {
+                            net::CookieOptions* options) OVERRIDE {
     return allow_all_cookies_;
   }
 
   size_t amount_sent() const { return amount_sent_; }
   const std::string& received_data() const { return received_data_; }
 
  private:
   int amount_sent_;
   bool allow_all_cookies_;
   std::string received_data_;
   base::Closure on_start_open_connection_;
   base::Closure on_connected_;
   base::Closure on_sent_data_;
   base::Closure on_received_data_;
   base::Closure on_close_;
 };
 
 class MockCookieStore : public net::CookieStore {
  public:
   struct Entry {
     GURL url;
     std::string cookie_line;
     net::CookieOptions options;
   };
+
   MockCookieStore() {}
 
-  virtual bool SetCookieWithOptions(const GURL& url,
-                                    const std::string& cookie_line,
-                                    const net::CookieOptions& options) {
+  bool SetCookieWithOptions(const GURL& url,
+                            const std::string& cookie_line,
+                            const net::CookieOptions& options) {
     Entry entry;
     entry.url = url;
     entry.cookie_line = cookie_line;
     entry.options = options;
     entries_.push_back(entry);
     return true;
   }
 
-  virtual void SetCookieWithOptionsAsync(
-      const GURL& url,
-      const std::string& cookie_line,
-      const net::CookieOptions& options,
-      const SetCookiesCallback& callback) {
-    bool result = SetCookieWithOptions(url, cookie_line, options);
-    if (!callback.is_null())
-      callback.Run(result);
-  }
-  virtual std::string GetCookiesWithOptions(
-      const GURL& url,
-      const net::CookieOptions& options) {
+  std::string GetCookiesWithOptions(const GURL& url,
+                                    const net::CookieOptions& options) {
     std::string result;
     for (size_t i = 0; i < entries_.size(); i++) {
       Entry &entry = entries_[i];
       if (url == entry.url) {
         if (!result.empty()) {
           result += "; ";
         }
         result += entry.cookie_line;
       }
     }
     return result;
   }
+
+  // CookieStore:
+  virtual void SetCookieWithOptionsAsync(
+      const GURL& url,
+      const std::string& cookie_line,
+      const net::CookieOptions& options,
+      const SetCookiesCallback& callback) OVERRIDE {
+    bool result = SetCookieWithOptions(url, cookie_line, options);
+    if (!callback.is_null())
+      callback.Run(result);
+  }
+
   virtual void GetCookiesWithOptionsAsync(
       const GURL& url,
       const net::CookieOptions& options,
-      const GetCookiesCallback& callback) {
-  if (!callback.is_null())
-    callback.Run(GetCookiesWithOptions(url, options));
+      const GetCookiesCallback& callback) OVERRIDE {
+    if (!callback.is_null())
+      callback.Run(GetCookiesWithOptions(url, options));
   }
-  virtual void GetCookiesWithInfo(const GURL& url,
-                                  const net::CookieOptions& options,
-                                  std::string* cookie_line,
-                                  std::vector<CookieInfo>* cookie_infos) {
-    ADD_FAILURE();
-  }
+
   virtual void GetCookiesWithInfoAsync(
       const GURL& url,
       const net::CookieOptions& options,
-      const GetCookieInfoCallback& callback) {
-    ADD_FAILURE();
-  }
-  virtual void DeleteCookie(const GURL& url,
-                            const std::string& cookie_name) {
-    ADD_FAILURE();
-  }
-  virtual void DeleteCookieAsync(const GURL& url,
-                                 const std::string& cookie_name,
-                                 const base::Closure& callback) {
-    ADD_FAILURE();
-  }
-  virtual void DeleteAllCreatedBetweenAsync(const base::Time& delete_begin,
-                                            const base::Time& delete_end,
-                                            const DeleteCallback& callback) {
-    ADD_FAILURE();
-  }
-  virtual void DeleteSessionCookiesAsync(const DeleteCallback&) {
+      const GetCookieInfoCallback& callback) OVERRIDE {
     ADD_FAILURE();
   }
 
-  virtual net::CookieMonster* GetCookieMonster() { return NULL; }
+  virtual void DeleteCookieAsync(const GURL& url,
+                                 const std::string& cookie_name,
+                                 const base::Closure& callback) OVERRIDE {
+    ADD_FAILURE();
+  }
+
+  virtual void DeleteAllCreatedBetweenAsync(
+      const base::Time& delete_begin,
+      const base::Time& delete_end,
+      const DeleteCallback& callback) OVERRIDE {
+    ADD_FAILURE();
+  }
+
+  virtual void DeleteSessionCookiesAsync(const DeleteCallback&) OVERRIDE {
+    ADD_FAILURE();
+  }
+
+  virtual net::CookieMonster* GetCookieMonster() OVERRIDE { return NULL; }
 
   const std::vector<Entry>& entries() const { return entries_; }
 
  private:
   friend class base::RefCountedThreadSafe<MockCookieStore>;
   virtual ~MockCookieStore() {}
 
   std::vector<Entry> entries_;
 };
 
 class MockSSLConfigService : public net::SSLConfigService {
  public:
-  virtual void GetSSLConfig(net::SSLConfig* config) {};
+  virtual void GetSSLConfig(net::SSLConfig* config) OVERRIDE {}
+
+ protected:
+  virtual ~MockSSLConfigService() {}
 };
 
 class MockURLRequestContext : public net::URLRequestContext {
  public:
   explicit MockURLRequestContext(net::CookieStore* cookie_store)
       : transport_security_state_(std::string()) {
     set_cookie_store(cookie_store);
     set_transport_security_state(&transport_security_state_);
     net::TransportSecurityState::DomainState state;
     state.expiry = base::Time::Now() + base::TimeDelta::FromSeconds(1000);
     transport_security_state_.EnableHost("upgrademe.com", state);
   }
 
- private:
+ protected:
   friend class base::RefCountedThreadSafe<MockURLRequestContext>;
   virtual ~MockURLRequestContext() {}
 
+ private:
   net::TransportSecurityState transport_security_state_;
 };
 
 class MockHttpTransactionFactory : public net::HttpTransactionFactory {
  public:
   MockHttpTransactionFactory(net::OrderedSocketData* data) {
     data_ = data;
     net::MockConnect connect_data(net::SYNCHRONOUS, net::OK);
     data_->set_connect_data(connect_data);
     session_deps_.reset(new SpdySessionDependencies);
@@ skipping 19 matching lines @@
     net::ClientSocketHandle* connection = new net::ClientSocketHandle;
     EXPECT_EQ(net::OK,
               connection->Init(host_port_pair_.ToString(), transport_params_,
                                net::MEDIUM, net::CompletionCallback(),
                                http_session_->GetTransportSocketPool(
                                    net::HttpNetworkSession::NORMAL_SOCKET_POOL),
                                net::BoundNetLog()));
     EXPECT_EQ(net::OK,
               session_->InitializeWithSocket(connection, false, net::OK));
   }
-  virtual int CreateTransaction(scoped_ptr<net::HttpTransaction>* trans) {
+
+  virtual int CreateTransaction(
+      scoped_ptr<net::HttpTransaction>* trans) OVERRIDE {
     NOTREACHED();
     return net::ERR_UNEXPECTED;
   }
-  virtual net::HttpCache* GetCache() {
+
+  virtual net::HttpCache* GetCache() OVERRIDE {
     NOTREACHED();
     return NULL;
   }
-  virtual net::HttpNetworkSession* GetSession() {
+
+  virtual net::HttpNetworkSession* GetSession() OVERRIDE {
     return http_session_.get();
   }
+
  private:
   net::OrderedSocketData* data_;
   scoped_ptr<SpdySessionDependencies> session_deps_;
   scoped_refptr<net::HttpNetworkSession> http_session_;
   scoped_refptr<net::TransportSocketParams> transport_params_;
   scoped_refptr<net::SpdySession> session_;
   net::HostPortPair host_port_pair_;
   net::HostPortProxyPair host_port_proxy_pair_;
 };
 }  // namespace
 
 namespace net {
 
 class WebSocketJobSpdy2Test : public PlatformTest {
  public:
-  virtual void SetUp() {
+  virtual void SetUp() OVERRIDE {
     SpdySession::set_default_protocol(kProtoSPDY2);
     stream_type_ = STREAM_INVALID;
     cookie_store_ = new MockCookieStore;
     context_ = new MockURLRequestContext(cookie_store_.get());
   }
-  virtual void TearDown() {
+  virtual void TearDown() OVERRIDE {
     cookie_store_ = NULL;
     context_ = NULL;
     websocket_ = NULL;
     socket_ = NULL;
   }
   void DoSendRequest() {
     EXPECT_TRUE(websocket_->SendData(kHandshakeRequestWithoutCookie,
                                      kHandshakeRequestWithoutCookieLength));
   }
   void DoSendData() {
@@ skipping 756 matching lines @@
 
 TEST_F(WebSocketJobSpdy2Test, ThrottlingSpdySpdyEnabled) {
   WebSocketJob::set_websocket_over_spdy_enabled(true);
   TestConnectBySpdy(SPDY_ON, THROTTLING_ON);
 }
 
 // TODO(toyoshim): Add tests to verify throttling, SPDY stream limitation.
 // TODO(toyoshim,yutak): Add tests to verify closing handshake.
 
 }  // namespace net