Fixed memory leak in SpdyHttpStreamTest. Removed suppressions.

net/spdy/spdy_stream_unittest.cc

 // Copyright (c) 2010 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/spdy/spdy_stream.h"
 #include "base/ref_counted.h"
-#include "base/time.h"
-#include "net/base/mock_host_resolver.h"
-#include "net/base/net_errors.h"
-#include "net/base/net_log.h"
-#include "net/base/ssl_config_service.h"
-#include "net/base/ssl_config_service_defaults.h"
-#include "net/base/test_completion_callback.h"
-#include "net/http/http_auth_handler_factory.h"
-#include "net/http/http_network_session.h"
-#include "net/http/http_request_info.h"
-#include "net/http/http_response_info.h"
-#include "net/proxy/proxy_service.h"
-#include "net/socket/socket_test_util.h"
-#include "net/spdy/spdy_framer.h"
 #include "net/spdy/spdy_session.h"
-#include "net/spdy/spdy_session_pool.h"
 #include "net/spdy/spdy_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 // TODO(ukai): factor out common part with spdy_http_stream_unittest.cc
 class SpdySessionPoolPeer {
  public:
   explicit SpdySessionPoolPeer(const scoped_refptr<SpdySessionPool>& pool)
       : pool_(pool) {}
 
   void RemoveSpdySession(const scoped_refptr<SpdySession>& session) {
     pool_->Remove(session);
   }
 
  private:
   const scoped_refptr<SpdySessionPool> pool_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdySessionPoolPeer);
 };
 
 namespace {
 
 // Create a proxy service which fails on all requests (falls back to direct).
 ProxyService* CreateNullProxyService() {
   return ProxyService::CreateNull();
 }
 
-// Helper to manage the lifetimes of the dependencies for a
-// SpdyNetworkTransaction.
-class SessionDependencies {
- public:
-  // Default set of dependencies -- "null" proxy service.
-  SessionDependencies()
-      : host_resolver(new MockHostResolver),
-        proxy_service(CreateNullProxyService()),
-        ssl_config_service(new SSLConfigServiceDefaults),
-        http_auth_handler_factory(HttpAuthHandlerFactory::CreateDefault()),
-        spdy_session_pool(new SpdySessionPool()) {}
-
-  // Custom proxy service dependency.
-  explicit SessionDependencies(ProxyService* proxy_service)
-      : host_resolver(new MockHostResolver),
-        proxy_service(proxy_service),
-        ssl_config_service(new SSLConfigServiceDefaults),
-        http_auth_handler_factory(HttpAuthHandlerFactory::CreateDefault()),
-        spdy_session_pool(new SpdySessionPool()) {}
-
-  scoped_refptr<MockHostResolverBase> host_resolver;
-  scoped_refptr<ProxyService> proxy_service;
-  scoped_refptr<SSLConfigService> ssl_config_service;
-  MockClientSocketFactory socket_factory;
-  scoped_ptr<HttpAuthHandlerFactory> http_auth_handler_factory;
-  scoped_refptr<SpdySessionPool> spdy_session_pool;
-};
-
-HttpNetworkSession* CreateSession(SessionDependencies* session_deps) {
-  return new HttpNetworkSession(session_deps->host_resolver,
-                                session_deps->proxy_service,
-                                &session_deps->socket_factory,
-                                session_deps->ssl_config_service,
-                                session_deps->spdy_session_pool,
-                                session_deps->http_auth_handler_factory.get(),
-                                NULL,
-                                NULL);
-}
-
 class TestSpdyStreamDelegate : public SpdyStream::Delegate {
  public:
   TestSpdyStreamDelegate(SpdyStream* stream,
                          IOBufferWithSize* buf,
                          CompletionCallback* callback)
       : stream_(stream),
         buf_(buf),
         callback_(callback),
         send_headers_completed_(false),
         response_(new spdy::SpdyHeaderBlock),
@@ skipping 79 matching lines @@
   }
 
   virtual void TearDown() {
     MessageLoop::current()->RunAllPending();
   }
 
   scoped_refptr<HttpNetworkSession> session_;
 };
 
 TEST_F(SpdyStreamTest, SendDataAfterOpen) {
-  SessionDependencies session_deps;
+  SpdySessionDependencies session_deps;
 
-  session_ = CreateSession(&session_deps);
+  session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps);
   SpdySessionPoolPeer pool_peer_(session_->spdy_session_pool());
 
   const SpdyHeaderInfo kSynStartHeader = {
     spdy::SYN_STREAM,
     1,
     0,
     SPDY_PRIORITY_LOWEST,
     spdy::CONTROL_FLAG_NONE,
     false,
     spdy::INVALID,
@@ skipping 75 matching lines @@
 
   EXPECT_TRUE(delegate->send_headers_completed());
   EXPECT_EQ("200", (*delegate->response())["status"]);
   EXPECT_EQ("HTTP/1.1", (*delegate->response())["version"]);
   EXPECT_EQ(std::string("\0hello!\xff", 8), delegate->received_data());
   EXPECT_EQ(8, delegate->data_sent());
   EXPECT_TRUE(delegate->closed());
 }
 
 }  // namespace net