Fixed memory leak in SpdyHttpStreamTest. Removed suppressions.

net/spdy/spdy_network_transaction_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/base/net_log_unittest.h"
+#include "net/http/http_transaction_unittest.h"
+#include "net/spdy/spdy_http_stream.h"
 #include "net/spdy/spdy_network_transaction.h"
-
-#include "base/basictypes.h"
-#include "base/ref_counted.h"
-#include "base/string_util.h"
-#include "net/base/completion_callback.h"
-#include "net/base/mock_host_resolver.h"
-#include "net/base/net_log_unittest.h"
-#include "net/base/request_priority.h"
-#include "net/base/ssl_config_service_defaults.h"
-#include "net/base/test_completion_callback.h"
-#include "net/base/upload_data.h"
-#include "net/http/http_auth_handler_factory.h"
-#include "net/http/http_network_session.h"
-#include "net/http/http_transaction_unittest.h"
-#include "net/proxy/proxy_config_service_fixed.h"
-#include "net/socket/socket_test_util.h"
-#include "net/spdy/spdy_framer.h"
-#include "net/spdy/spdy_http_stream.h"
-#include "net/spdy/spdy_protocol.h"
 #include "net/spdy/spdy_test_util.h"
 #include "testing/platform_test.h"
 
 //-----------------------------------------------------------------------------
 
 namespace net {
 
 class SpdyNetworkTransactionTest : public PlatformTest {
  protected:
   virtual void SetUp() {
@@ skipping 20 matching lines @@
     HttpResponseInfo response_info;
   };
 
   void EnableCompression(bool enabled) {
     spdy::SpdyFramer::set_enable_compression_default(enabled);
   }
 
   class StartTransactionCallback;
   class DeleteSessionCallback;
 
-  // Helper to manage the lifetimes of the dependencies for a
-  // HttpNetworkTransaction.
-  class SessionDependencies {
-   public:
-    // Default set of dependencies -- "null" proxy service.
-    SessionDependencies()
-        : host_resolver(new MockHostResolver),
-          proxy_service(ProxyService::CreateNull()),
-          ssl_config_service(new SSLConfigServiceDefaults),
-          http_auth_handler_factory(HttpAuthHandlerFactory::CreateDefault()),
-          spdy_session_pool(new SpdySessionPool()) {
-          // Note: The CancelledTransaction test does cleanup by running all
-          // tasks in the message loop (RunAllPending).  Unfortunately, that
-          // doesn't clean up tasks on the host resolver thread; and
-          // TCPConnectJob is currently not cancellable.  Using synchronous
-          // lookups allows the test to shutdown cleanly.  Until we have
-          // cancellable TCPConnectJobs, use synchronous lookups.
-          host_resolver->set_synchronous_mode(true);
-        }
-
-    // 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;
-  };
-
-  static 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);
-  }
-
   // A helper class that handles all the initial npn/ssl setup.
   class NormalSpdyTransactionHelper {
    public:
     NormalSpdyTransactionHelper(const HttpRequestInfo& request,
                                 const BoundNetLog& log)
-        : request_(request), session_(CreateSession(&session_deps_)),
+        : request_(request),
+          session_(SpdySessionDependencies::SpdyCreateSession(&session_deps_)),
           log_(log), add_data_allowed_(true) {}
 
     void RunPreTestSetup() {
       // Disallow future calls to AddData
       add_data_allowed_ = false;
 
       // Set up http data.
       MockRead data_reads[] = {
         MockRead("HTTP/1.1 200 OK\r\n"),
         MockRead("Alternate-Protocol: 443:npn-spdy/1\r\n\r\n"),
@@ skipping 130 matching lines @@
     HttpNetworkTransaction* trans() { return trans_.get(); }
     void ResetTrans() { trans_.reset(); }
     TransactionHelperResult& output() { return output_; }
     HttpRequestInfo& request() { return request_; }
     scoped_refptr<HttpNetworkSession>& session() { return session_; }
 
    private:
     typedef std::vector<StaticSocketDataProvider*> DataVector;
     typedef std::vector<linked_ptr<SSLSocketDataProvider> > SSLVector;
     HttpRequestInfo request_;
-    SessionDependencies session_deps_;
+    SpdySessionDependencies session_deps_;
     scoped_refptr<HttpNetworkSession> session_;
     TransactionHelperResult output_;
     scoped_ptr<StaticSocketDataProvider> first_transaction_;
     SSLVector ssl_vector_;
     TestCompletionCallback callback;
     scoped_ptr<HttpNetworkTransaction> trans_;
     scoped_ptr<HttpNetworkTransaction> trans_http_;
     DataVector data_vector_;
     const BoundNetLog& log_;
     bool add_data_allowed_;
@@ skipping 16 matching lines @@
 
  private:
   bool google_get_request_initialized_;
   HttpRequestInfo google_get_request_;
 };
 
 //-----------------------------------------------------------------------------
 
 // Verify HttpNetworkTransaction constructor.
 TEST_F(SpdyNetworkTransactionTest, Constructor) {
-  SessionDependencies session_deps;
+  SpdySessionDependencies session_deps;
   scoped_refptr<HttpNetworkSession> session =
-      CreateSession(&session_deps);
+      SpdySessionDependencies::SpdyCreateSession(&session_deps);
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session));
 }
 
 TEST_F(SpdyNetworkTransactionTest, Get) {
   // Construct the request.
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite writes[] = { CreateMockWrite(*req) };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
@@ skipping 60 matching lines @@
     MockRead(true, 0, 0),  // EOF
   };
 
   scoped_refptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   BoundNetLog log;
   TransactionHelperResult out;
   {
-    SessionDependencies session_deps;
-    HttpNetworkSession* session = CreateSession(&session_deps);
+    SpdySessionDependencies session_deps;
+    HttpNetworkSession* session =
+        SpdySessionDependencies::SpdyCreateSession(&session_deps);
     SpdySession::SetSSLMode(false);
     scoped_ptr<SpdyNetworkTransaction> trans1(
         new SpdyNetworkTransaction(session));
     scoped_ptr<SpdyNetworkTransaction> trans2(
         new SpdyNetworkTransaction(session));
     scoped_ptr<SpdyNetworkTransaction> trans3(
         new SpdyNetworkTransaction(session));
 
     session_deps.socket_factory.AddSocketDataProvider(data);
 
@@ skipping 87 matching lines @@
     MockRead(true, 0, 0),  // EOF
   };
 
   scoped_refptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   BoundNetLog log;
   TransactionHelperResult out;
   {
-    SessionDependencies session_deps;
-    HttpNetworkSession* session = CreateSession(&session_deps);
+    SpdySessionDependencies session_deps;
+    HttpNetworkSession* session =
+        SpdySessionDependencies::SpdyCreateSession(&session_deps);
     SpdySession::SetSSLMode(false);
     scoped_ptr<SpdyNetworkTransaction> trans1(
         new SpdyNetworkTransaction(session));
     scoped_ptr<SpdyNetworkTransaction> trans2(
         new SpdyNetworkTransaction(session));
     scoped_ptr<SpdyNetworkTransaction> trans3(
         new SpdyNetworkTransaction(session));
 
     session_deps.socket_factory.AddSocketDataProvider(data);
 
@@ skipping 112 matching lines @@
     MockRead(true, 0, 0),  // EOF
   };
 
   scoped_refptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   BoundNetLog log;
   TransactionHelperResult out;
   {
-    SessionDependencies session_deps;
-    HttpNetworkSession* session = CreateSession(&session_deps);
+    SpdySessionDependencies session_deps;
+    HttpNetworkSession* session =
+        SpdySessionDependencies::SpdyCreateSession(&session_deps);
     SpdySession::SetSSLMode(false);
     scoped_ptr<SpdyNetworkTransaction> trans1(
         new SpdyNetworkTransaction(session));
     scoped_ptr<SpdyNetworkTransaction> trans2(
         new SpdyNetworkTransaction(session));
     scoped_ptr<SpdyNetworkTransaction> trans3(
         new SpdyNetworkTransaction(session));
     scoped_ptr<SpdyNetworkTransaction> trans4(
         new SpdyNetworkTransaction(session));
 
@@ skipping 118 matching lines @@
     MockRead(true, 0, 0),  // EOF
   };
 
   scoped_refptr<OrderedSocketData> data(
       new OrderedSocketData(reads, arraysize(reads),
                             writes, arraysize(writes)));
 
   BoundNetLog log;
   TransactionHelperResult out;
   {
-    SessionDependencies session_deps;
-    HttpNetworkSession* session = CreateSession(&session_deps);
+    SpdySessionDependencies session_deps;
+    HttpNetworkSession* session =
+        SpdySessionDependencies::SpdyCreateSession(&session_deps);
     SpdySession::SetSSLMode(false);
     scoped_ptr<SpdyNetworkTransaction> trans1(
         new SpdyNetworkTransaction(session));
     scoped_ptr<SpdyNetworkTransaction> trans2(
         new SpdyNetworkTransaction(session));
     scoped_ptr<SpdyNetworkTransaction> trans3(
         new SpdyNetworkTransaction(session));
 
     session_deps.socket_factory.AddSocketDataProvider(data);
 
@@ skipping 210 matching lines @@
   EXPECT_TRUE(response->was_fetched_via_spdy);
   std::string response_data;
   rv = ReadTransaction(trans, &response_data);
   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, rv);
 
   helper.VerifyDataConsumed();
 }
 
 // Test that WINDOW_UPDATE frames change window_size correctly.
 TEST_F(SpdyNetworkTransactionTest, WindowUpdate) {
-  SessionDependencies session_deps;
-  scoped_refptr<HttpNetworkSession> session = CreateSession(&session_deps);
+  SpdySessionDependencies session_deps;
+  scoped_refptr<HttpNetworkSession> session =
+      SpdySessionDependencies::SpdyCreateSession(&session_deps);
 
   // We disable SSL for this test.
   SpdySession::SetSSLMode(false);
 
   // Setup the request
   static const char upload[] = { "hello!" };
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.google.com/");
   request.upload_data = new UploadData();
@@ skipping 40 matching lines @@
   ASSERT_TRUE(trans->stream_ != NULL);
   ASSERT_TRUE(trans->stream_->stream() != NULL);
   EXPECT_EQ(spdy::kInitialWindowSize + kDeltaWindowSize,
             trans->stream_->stream()->window_size());
   EXPECT_TRUE(data->at_read_eof());
   EXPECT_TRUE(data->at_write_eof());
 }
 
 // Test that WINDOW_UPDATE frame causing overflow is handled correctly.
 TEST_F(SpdyNetworkTransactionTest, WindowUpdateOverflow) {
-  SessionDependencies session_deps;
-  scoped_refptr<HttpNetworkSession> session = CreateSession(&session_deps);
+  SpdySessionDependencies session_deps;
+  scoped_refptr<HttpNetworkSession> session =
+      SpdySessionDependencies::SpdyCreateSession(&session_deps);
 
   // We disable SSL for this test.
   SpdySession::SetSSLMode(false);
 
   // Setup the request
   static const char upload[] = { "hello!" };
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.google.com/");
   request.upload_data = new UploadData();
@@ skipping 72 matching lines @@
                                      BoundNetLog());
   helper.AddData(&data);
   helper.RunPreTestSetup();
   HttpNetworkTransaction* trans = helper.trans();
 
   TestCompletionCallback callback;
   int rv = trans->Start(&CreateGetRequest(), &callback, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   helper.ResetTrans();  // Cancel the transaction.
 
-  // Flush the MessageLoop while the SessionDependencies (in particular, the
+  // Flush the MessageLoop while the SpdySessionDependencies (in particular, the
   // MockClientSocketFactory) are still alive.
   MessageLoop::current()->RunAllPending();
   helper.VerifyDataNotConsumed();
 }
 
 class SpdyNetworkTransactionTest::StartTransactionCallback
     : public CallbackRunner< Tuple1<int> > {
  public:
   explicit StartTransactionCallback(
       scoped_refptr<HttpNetworkSession>& session,
@@ skipping 713 matching lines @@
     }
     if (rv > 0) {
       content.append(buf->data(), rv);
     } else if (rv < 0) {
       NOTREACHED();
     }
   } while (rv > 0);
 
   out.response_data.swap(content);
 
-  // Flush the MessageLoop while the SessionDependencies (in particular, the
+  // Flush the MessageLoop while the SpdySessionDependencies (in particular, the
   // MockClientSocketFactory) are still alive.
   MessageLoop::current()->RunAllPending();
 
   // Verify that we consumed all test data.
   helper.VerifyDataConsumed();
 
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("goodbye world", out.response_data);
 }
@@ skipping 143 matching lines @@
     } else if (rv < 0) {
       FAIL() << "Unexpected read error: " << rv;
     }
     reads_completed++;
   } while (rv > 0);
 
   EXPECT_EQ(3, reads_completed);  // Reads are: 14 bytes, 14 bytes, 0 bytes.
 
   out.response_data.swap(content);
 
-  // Flush the MessageLoop while the SessionDependencies (in particular, the
+  // Flush the MessageLoop while the SpdySessionDependencies (in particular, the
   // MockClientSocketFactory) are still alive.
   MessageLoop::current()->RunAllPending();
 
   // Verify that we consumed all test data.
   helper.VerifyDataConsumed();
 
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("messagemessagemessagemessage", out.response_data);
 }
@@ skipping 70 matching lines @@
     } else if (rv < 0) {
       FAIL() << "Unexpected read error: " << rv;
     }
     reads_completed++;
   } while (rv > 0);
 
   EXPECT_EQ(3, reads_completed);
 
   out.response_data.swap(content);
 
-  // Flush the MessageLoop while the SessionDependencies (in particular, the
+  // Flush the MessageLoop while the SpdySessionDependencies (in particular, the
   // MockClientSocketFactory) are still alive.
   MessageLoop::current()->RunAllPending();
 
   // Verify that we consumed all test data.
   helper.VerifyDataConsumed();
 
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("messagemessagemessagemessage", out.response_data);
 }
@@ skipping 73 matching lines @@
       EXPECT_EQ(ERR_CONNECTION_CLOSED, rv);
       break;
     }
     reads_completed++;
   } while (rv > 0);
 
   EXPECT_EQ(0, reads_completed);
 
   out.response_data.swap(content);
 
-  // Flush the MessageLoop while the SessionDependencies (in particular, the
+  // Flush the MessageLoop while the SpdySessionDependencies (in particular, the
   // MockClientSocketFactory) are still alive.
   MessageLoop::current()->RunAllPending();
 
   // Verify that we consumed all test data.
   helper.VerifyDataConsumed();
 }
 
 // Verify the case where we buffer data and cancel the transaction.
 TEST_F(SpdyNetworkTransactionTest, BufferedCancelled) {
   spdy::SpdyFramer framer;
@@ skipping 328 matching lines @@
   EXPECT_TRUE(response->headers != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.rv = ReadTransaction(trans, &out.response_data);
   EXPECT_EQ(ERR_CONNECTION_CLOSED, out.rv);
 
   // Verify that we consumed all test data.
   helper.VerifyDataConsumed();
 }
 
 }  // namespace net