SPDY - default to SPDY/2.1 protocol in unittests

net/http/http_pipelined_host_impl_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/http/http_pipelined_host_impl.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "net/base/ssl_config_service.h"
 #include "net/http/http_pipelined_connection.h"
 #include "net/proxy/proxy_info.h"
@@ skipping 85 matching lines @@
     host_.reset(new HttpPipelinedHostImpl(
         &delegate_, origin_, factory_, capability));
   }
 
   MockPipeline* AddTestPipeline(int depth, bool usable, bool active) {
     MockPipeline* pipeline = new MockPipeline(depth, usable, active);
     EXPECT_CALL(*factory_, CreateNewPipeline(kDummyConnection, host_.get(),
                                              MatchesOrigin(origin_),
                                              Ref(ssl_config_), Ref(proxy_info_),
                                              Ref(net_log_), true,
-                                             SSLClientSocket::kProtoSPDY2))
+                                             SSLClientSocket::kProtoSPDY21))
         .Times(1)
         .WillOnce(Return(pipeline));
     EXPECT_CALL(*pipeline, CreateNewStream())
         .Times(1)
         .WillOnce(Return(kDummyStream));
     EXPECT_EQ(kDummyStream, host_->CreateStreamOnNewPipeline(
         kDummyConnection, ssl_config_, proxy_info_, net_log_, true,
-        SSLClientSocket::kProtoSPDY2));
+        SSLClientSocket::kProtoSPDY21));
     return pipeline;
   }
 
   void ClearTestPipeline(MockPipeline* pipeline) {
     pipeline->SetState(0, true, true);
     host_->OnPipelineHasCapacity(pipeline);
   }
 
   NiceMock<MockHostDelegate> delegate_;
   HostPortPair origin_;
@@ skipping 131 matching lines @@
       .Times(0);
   EXPECT_CALL(delegate_,
               OnHostDeterminedCapability(host_.get(), PIPELINE_INCAPABLE))
       .Times(1);
   host_->OnPipelineFeedback(pipeline,
                             HttpPipelinedConnection::OLD_HTTP_VERSION);
 
   ClearTestPipeline(pipeline);
   EXPECT_EQ(NULL, host_->CreateStreamOnNewPipeline(
       kDummyConnection, ssl_config_, proxy_info_, net_log_, true,
-      SSLClientSocket::kProtoSPDY2));
+      SSLClientSocket::kProtoSPDY21));
 }
 
 TEST_F(HttpPipelinedHostImplTest, ShutsDownOnAuthenticationRequired) {
   SetCapability(PIPELINE_UNKNOWN);
   MockPipeline* pipeline = AddTestPipeline(1, true, true);
 
   EXPECT_EQ(NULL, host_->CreateStreamOnExistingPipeline());
   EXPECT_CALL(delegate_, OnHostHasAdditionalCapacity(host_.get()))
       .Times(0);
   EXPECT_CALL(delegate_,
@@ skipping 77 matching lines @@
       .Times(1);
   host_->OnPipelineFeedback(pipeline,
                             HttpPipelinedConnection::PIPELINE_SOCKET_ERROR);
 
   ClearTestPipeline(pipeline);
 }
 
 }  // anonymous namespace
 
 }  // namespace net