Fixes to socket_test_util.cc.

net/websockets/websocket_job_unittest.cc

 // Copyright (c) 2011 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 238 matching lines @@
 
  private:
   friend class base::RefCountedThreadSafe<MockURLRequestContext>;
   virtual ~MockURLRequestContext() {}
 
   net::TransportSecurityState transport_security_state_;
 };
 
 class MockHttpTransactionFactory : public net::HttpTransactionFactory {
  public:
-  MockHttpTransactionFactory(scoped_refptr<net::OrderedSocketData>& data) {
+  MockHttpTransactionFactory(net::OrderedSocketData* data) {
     data_ = data;
     net::MockConnect connect_data(false, net::OK);
     data_->set_connect_data(connect_data);
     session_deps_.reset(new net::SpdySessionDependencies);
-    session_deps_->socket_factory->AddSocketDataProvider(data_.get());
+    session_deps_->socket_factory->AddSocketDataProvider(data_);
     http_session_ =
         net::SpdySessionDependencies::SpdyCreateSession(session_deps_.get());
     host_port_pair_.set_host("example.com");
     host_port_pair_.set_port(80);
     host_port_proxy_pair_.first = host_port_pair_;
     host_port_proxy_pair_.second = net::ProxyServer::Direct();
     net::SpdySessionPool* spdy_session_pool =
         http_session_->spdy_session_pool();
     DCHECK(spdy_session_pool);
     EXPECT_FALSE(spdy_session_pool->HasSession(host_port_proxy_pair_));
@@ skipping 19 matching lines @@
     return net::ERR_UNEXPECTED;
   }
   virtual net::HttpCache* GetCache() {
     NOTREACHED();
     return NULL;
   }
   virtual net::HttpNetworkSession* GetSession() {
     return http_session_.get();
   }
  private:
-  scoped_refptr<net::OrderedSocketData> data_;
+  net::OrderedSocketData* data_;
   scoped_ptr<net::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 net {
@@ skipping 46 matching lines @@
                         StreamType stream_type) {
     DCHECK_NE(STREAM_INVALID, stream_type);
     stream_type_ = stream_type;
     websocket_ = new WebSocketJob(delegate);
 
     if (stream_type == STREAM_MOCK_SOCKET)
       socket_ = new MockSocketStream(url, websocket_.get());
 
     if (stream_type == STREAM_SOCKET || stream_type == STREAM_SPDY_WEBSOCKET) {
       if (stream_type == STREAM_SPDY_WEBSOCKET) {
-        http_factory_.reset(new MockHttpTransactionFactory(data_));
+        http_factory_.reset(new MockHttpTransactionFactory(data_.get()));
         context_->set_http_transaction_factory(http_factory_.get());
       }
 
       ssl_config_service_ = new MockSSLConfigService();
       context_->set_ssl_config_service(ssl_config_service_);
       proxy_service_.reset(net::ProxyService::CreateDirect());
       context_->set_proxy_service(proxy_service_.get());
       host_resolver_.reset(new net::MockHostResolver);
       context_->set_host_resolver(host_resolver_.get());
 
@@ skipping 59 matching lines @@
   void TestInvalidSendData();
   void TestConnectByWebSocket(ThrottlingOption throttling);
   void TestConnectBySpdy(SpdyOption spdy, ThrottlingOption throttling);
 
   StreamType stream_type_;
   scoped_refptr<MockCookieStore> cookie_store_;
   scoped_refptr<MockURLRequestContext> context_;
   scoped_refptr<WebSocketJob> websocket_;
   scoped_refptr<SocketStream> socket_;
   scoped_ptr<MockClientSocketFactory> socket_factory_;
-  scoped_refptr<OrderedSocketData> data_;
+  scoped_ptr<OrderedSocketData> data_;
   TestCompletionCallback sync_test_callback_;
   scoped_refptr<MockSSLConfigService> ssl_config_service_;
   scoped_ptr<net::ProxyService> proxy_service_;
   scoped_ptr<net::MockHostResolver> host_resolver_;
   scoped_ptr<MockHttpTransactionFactory> http_factory_;
 
   static const char kHandshakeRequestWithoutCookie[];
   static const char kHandshakeRequestWithCookie[];
   static const char kHandshakeRequestWithFilteredCookie[];
   static const char kHandshakeResponseWithoutCookie[];
@@ skipping 358 matching lines @@
     MockRead(true,
              kHandshakeResponseWithoutCookie,
              kHandshakeResponseWithoutCookieLength,
              2),
     MockRead(true,
              kDataWorld,
              kDataWorldLength,
              4),
     MockRead(false, 0, 5)  // EOF
   };
-  data_ = new OrderedSocketData(
-      reads, arraysize(reads), writes, arraysize(writes));
+  data_.reset(new OrderedSocketData(
+      reads, arraysize(reads), writes, arraysize(writes)));
 
   GURL url("ws://example.com/demo");
   MockSocketStreamDelegate delegate;
   WebSocketJobTest* test = this;
   if (throttling == THROTTLING_ON)
     delegate.SetOnStartOpenConnection(
         base::Bind(&WebSocketJobTest::DoSync, base::Unretained(test)));
   delegate.SetOnConnected(
       base::Bind(&WebSocketJobTest::DoSendRequest, base::Unretained(test)));
   delegate.SetOnReceivedData(
@@ skipping 88 matching lines @@
     CreateMockWrite(*request_frame.get(), 1),
     CreateMockWrite(*data_hello_frame.get(), 3),
   };
   MockRead reads_spdy[] = {
     CreateMockRead(*response_frame.get(), 2),
     CreateMockRead(*data_world_frame.get(), 4),
     MockRead(false, 0, 5)  // EOF
   };
 
   if (spdy == SPDY_ON)
-    data_ = new OrderedSocketData(
+    data_.reset(new OrderedSocketData(
         reads_spdy, arraysize(reads_spdy),
-        writes_spdy, arraysize(writes_spdy));
+        writes_spdy, arraysize(writes_spdy)));
   else
-    data_ = new OrderedSocketData(
+    data_.reset(new OrderedSocketData(
         reads_websocket, arraysize(reads_websocket),
-        writes_websocket, arraysize(writes_websocket));
+        writes_websocket, arraysize(writes_websocket)));
 
   GURL url("ws://example.com/demo");
   MockSocketStreamDelegate delegate;
   WebSocketJobTest* test = this;
   if (throttling == THROTTLING_ON)
     delegate.SetOnStartOpenConnection(
         base::Bind(&WebSocketJobTest::DoSync, base::Unretained(test)));
   delegate.SetOnConnected(
       base::Bind(&WebSocketJobTest::DoSendRequest, base::Unretained(test)));
   delegate.SetOnReceivedData(
@@ skipping 128 matching lines @@
 
 TEST_F(WebSocketJobTest, 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