Move NextProto enum to a new file net/socket/next_proto.h

net/http/http_pipelined_host_pool_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_pool.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/rand_util.h"
 #include "net/base/ssl_config_service.h"
 #include "net/http/http_pipelined_host.h"
@@ skipping 38 matching lines @@
   MockHost(const Key& key)
       : key_(key) {
   }
 
   MOCK_METHOD6(CreateStreamOnNewPipeline, HttpPipelinedStream*(
       ClientSocketHandle* connection,
       const SSLConfig& used_ssl_config,
       const ProxyInfo& used_proxy_info,
       const BoundNetLog& net_log,
       bool was_npn_negotiated,
-      SSLClientSocket::NextProto protocol_negotiated));
+      NextProto protocol_negotiated));
   MOCK_METHOD0(CreateStreamOnExistingPipeline, HttpPipelinedStream*());
   MOCK_CONST_METHOD0(IsExistingPipelineAvailable, bool());
   MOCK_CONST_METHOD0(PipelineInfoToValue, base::Value*());
 
   virtual const Key& GetKey() const OVERRIDE { return key_; }
 
  private:
   Key key_;
 };
 
 class HttpPipelinedHostPoolTest : public testing::Test {
  public:
   HttpPipelinedHostPoolTest()
       : key_(HostPortPair("host", 123)),
         factory_(new MockHostFactory),  // Owned by pool_.
         host_(new MockHost(key_)),  // Owned by pool_.
         http_server_properties_(new HttpServerPropertiesImpl),
         pool_(new HttpPipelinedHostPool(&delegate_, factory_,
                                         http_server_properties_.get(), false)),
         was_npn_negotiated_(false),
-        protocol_negotiated_(SSLClientSocket::kProtoUnknown) {
+        protocol_negotiated_(kProtoUnknown) {
   }
 
   void CreateDummyStream(const HttpPipelinedHost::Key& key,
                          ClientSocketHandle* connection,
                          HttpPipelinedStream* stream,
                          MockHost* host) {
     EXPECT_CALL(*host, CreateStreamOnNewPipeline(connection,
                                                  Ref(ssl_config_),
                                                  Ref(proxy_info_),
                                                  Ref(net_log_),
@@ skipping 26 matching lines @@
   MockPoolDelegate delegate_;
   MockHostFactory* factory_;
   MockHost* host_;
   scoped_ptr<HttpServerPropertiesImpl> http_server_properties_;
   scoped_ptr<HttpPipelinedHostPool> pool_;
 
   const SSLConfig ssl_config_;
   const ProxyInfo proxy_info_;
   const BoundNetLog net_log_;
   bool was_npn_negotiated_;
-  SSLClientSocket::NextProto protocol_negotiated_;
+  NextProto protocol_negotiated_;
 };
 
 TEST_F(HttpPipelinedHostPoolTest, DefaultUnknown) {
   EXPECT_TRUE(pool_->IsKeyEligibleForPipelining(key_));
   EXPECT_CALL(*factory_, CreateNewHost(pool_.get(), Ref(key_), _,
                                        PIPELINE_UNKNOWN, false))
       .Times(1)
       .WillOnce(Return(host_));
 
   CreateDummyStream(key_, kDummyConnection, kDummyStream, host_);
@@ skipping 114 matching lines @@
   pool_->OnHostIdle(host1);
   pool_->OnHostIdle(host2);
   pool_->OnHostIdle(host3);
 
   delete host_;  // Must manually delete, because it's never added to |pool_|.
 }
 
 }  // anonymous namespace
 
 }  // namespace net