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

net/spdy/spdy_session.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/spdy/spdy_session.h"
 
 #include <map>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 274 matching lines @@
 
  private:
   ~NetLogSpdyGoAwayParameter() {}
   const SpdyStreamId last_stream_id_;
   const int active_streams_;
   const int unclaimed_streams_;
 
   DISALLOW_COPY_AND_ASSIGN(NetLogSpdyGoAwayParameter);
 };
 
-SSLClientSocket::NextProto g_default_protocol = SSLClientSocket::kProtoUnknown;
+NextProto g_default_protocol = kProtoUnknown;
 size_t g_init_max_concurrent_streams = 10;
 size_t g_max_concurrent_stream_limit = 256;
 bool g_enable_ping_based_connection_checking = true;
 
 }  // namespace
 
 // static
-void SpdySession::set_default_protocol(
-    SSLClientSocket::NextProto default_protocol) {
+void SpdySession::set_default_protocol(NextProto default_protocol) {
   g_default_protocol = default_protocol;
 }
 
 // static
 void SpdySession::set_max_concurrent_streams(size_t value) {
   g_max_concurrent_stream_limit = value;
 }
 
 // static
 void SpdySession::set_enable_ping_based_connection_checking(bool enable) {
   g_enable_ping_based_connection_checking = enable;
 }
 
 // static
 void SpdySession::set_init_max_concurrent_streams(size_t value) {
   g_init_max_concurrent_streams =
       std::min(value, g_max_concurrent_stream_limit);
 }
 
 // static
 void SpdySession::ResetStaticSettingsToInit() {
   // WARNING: These must match the initializers above.
-  g_default_protocol = SSLClientSocket::kProtoUnknown;
+  g_default_protocol = kProtoUnknown;
   g_init_max_concurrent_streams = 10;
   g_max_concurrent_stream_limit = 256;
   g_enable_ping_based_connection_checking = true;
 }
 
 SpdySession::SpdySession(const HostPortProxyPair& host_port_proxy_pair,
                          SpdySessionPool* spdy_session_pool,
                          HttpServerProperties* http_server_properties,
                          bool verify_domain_authentication,
                          NetLog* net_log)
@@ skipping 79 matching lines @@
     bool is_secure,
     int certificate_error_code) {
   base::StatsCounter spdy_sessions("spdy.sessions");
   spdy_sessions.Increment();
 
   state_ = CONNECTED;
   connection_.reset(connection);
   is_secure_ = is_secure;
   certificate_error_code_ = certificate_error_code;
 
-  SSLClientSocket::NextProto protocol = g_default_protocol;
+  NextProto protocol = g_default_protocol;
   if (is_secure_) {
     SSLClientSocket* ssl_socket = GetSSLClientSocket();
-
-    SSLClientSocket::NextProto protocol_negotiated =
-        ssl_socket->protocol_negotiated();
-    if (protocol_negotiated != SSLClientSocket::kProtoUnknown) {
+    NextProto protocol_negotiated = ssl_socket->protocol_negotiated();
+    if (protocol_negotiated != kProtoUnknown) {
       protocol = protocol_negotiated;
     }
 
     if (ssl_socket->WasDomainBoundCertSent()) {
       // According to the SPDY spec, the credential associated with the TLS
       // connection is stored in slot[1].
       credential_state_.SetHasCredential(GURL("https://" +
                                               host_port_pair().ToString()));
     }
   }
 
-  DCHECK(protocol >= SSLClientSocket::kProtoSPDY2);
-  DCHECK(protocol <= SSLClientSocket::kProtoSPDY3);
-  int version = (protocol == SSLClientSocket::kProtoSPDY3) ? 3 : 2;
-  flow_control_ = (protocol >= SSLClientSocket::kProtoSPDY21);
+  DCHECK(protocol >= kProtoSPDY2);
+  DCHECK(protocol <= kProtoSPDY3);
+  int version = (protocol == kProtoSPDY3) ? 3 : 2;
+  flow_control_ = (protocol >= kProtoSPDY21);
 
   buffered_spdy_framer_.reset(new BufferedSpdyFramer(version));
   buffered_spdy_framer_->set_visitor(this);
   SendSettings();
 
   // Write out any data that we might have to send, such as the settings frame.
   WriteSocketLater();
   net::Error error = ReadSocket();
   if (error == ERR_IO_PENDING)
     return OK;
   return error;
 }
 
 bool SpdySession::VerifyDomainAuthentication(const std::string& domain) {
   if (!verify_domain_authentication_)
     return true;
 
   if (state_ != CONNECTED)
     return false;
 
   SSLInfo ssl_info;
   bool was_npn_negotiated;
-  SSLClientSocket::NextProto protocol_negotiated =
-      SSLClientSocket::kProtoUnknown;
+  NextProto protocol_negotiated =
+      kProtoUnknown;

[wtc, 2012/03/30 20:53:51]

Nit: move this to the previous line.

[Ryan Hamilton, 2012/03/30 21:12:13]

Done.

   if (!GetSSLInfo(&ssl_info, &was_npn_negotiated, &protocol_negotiated))
     return true;   // This is not a secure session, so all domains are okay.
 
   return !ssl_info.client_cert_sent && ssl_info.cert->VerifyNameMatch(domain);
 }
 
 int SpdySession::GetPushStream(
     const GURL& url,
     scoped_refptr<SpdyStream>* stream,
     const BoundNetLog& stream_net_log) {
@@ skipping 135 matching lines @@
   DCHECK(priority >= net::HIGHEST && priority < net::NUM_PRIORITIES);
 
   DCHECK_EQ(active_streams_[stream_id].get(), stream.get());
   return OK;
 }
 
 bool SpdySession::NeedsCredentials() const {
   if (!is_secure_)
     return false;
   SSLClientSocket* ssl_socket = GetSSLClientSocket();
-  if (ssl_socket->protocol_negotiated() < SSLClientSocket::kProtoSPDY3)
+  if (ssl_socket->protocol_negotiated() < kProtoSPDY3)
     return false;
   return ssl_socket->WasDomainBoundCertSent();
 }
 
 void SpdySession::AddPooledAlias(const HostPortProxyPair& alias) {
   pooled_aliases_.insert(alias);
 }
 
 int SpdySession::GetProtocolVersion() const {
   DCHECK(buffered_spdy_framer_.get());
@@ skipping 531 matching lines @@
   }
   dict->SetString("proxy", host_port_proxy_pair_.second.ToURI());
 
   dict->SetInteger("active_streams", active_streams_.size());
 
   dict->SetInteger("unclaimed_pushed_streams",
       unclaimed_pushed_streams_.size());
 
   dict->SetBoolean("is_secure", is_secure_);
 
-  SSLClientSocket::NextProto proto = SSLClientSocket::kProtoUnknown;
+  NextProto proto = kProtoUnknown;
   if (is_secure_) {
     proto = GetSSLClientSocket()->protocol_negotiated();
   }
   dict->SetString("protocol_negotiated",
                   SSLClientSocket::NextProtoToString(proto));
 
   dict->SetInteger("error", error_);
   dict->SetInteger("max_concurrent_streams", max_concurrent_streams_);
 
   dict->SetInteger("streams_initiated_count", streams_initiated_count_);
@@ skipping 81 matching lines @@
     scoped_refptr<SpdyStream> stream = it->second;
     unclaimed_pushed_streams_.erase(it);
     used_push_streams.Increment();
     return stream;
   }
   return NULL;
 }
 
 bool SpdySession::GetSSLInfo(SSLInfo* ssl_info,
                              bool* was_npn_negotiated,
-                             SSLClientSocket::NextProto* protocol_negotiated) {
+                             NextProto* protocol_negotiated) {
   if (!is_secure_) {
-    *protocol_negotiated = SSLClientSocket::kProtoUnknown;
+    *protocol_negotiated = kProtoUnknown;
     return false;
   }
   SSLClientSocket* ssl_socket = GetSSLClientSocket();
   ssl_socket->GetSSLInfo(ssl_info);
   *was_npn_negotiated = ssl_socket->was_npn_negotiated();
   *protocol_negotiated = ssl_socket->protocol_negotiated();
   return true;
 }
 
 bool SpdySession::GetSSLCertRequestInfo(
@@ skipping 655 matching lines @@
 SSLClientSocket* SpdySession::GetSSLClientSocket() const {
   if (!is_secure_)
     return NULL;
   SSLClientSocket* ssl_socket =
       reinterpret_cast<SSLClientSocket*>(connection_->socket());
   DCHECK(ssl_socket);
   return ssl_socket;
 }
 
 }  // namespace net