Revert of Unify enum NextProto and enum AlternateProtocol.

net/http/http_stream_factory_impl_job.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_stream_factory_impl_job.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 122 matching lines @@
   return std::move(dict);
 }
 
 // Returns parameters associated with the Proto (with NPN negotiation) of a HTTP
 // stream.
 std::unique_ptr<base::Value> NetLogHttpStreamProtoCallback(
     NextProto negotiated_protocol,
     NetLogCaptureMode /* capture_mode */) {
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
 
-  dict->SetString("proto", NextProtoToString(negotiated_protocol));
+  dict->SetString("proto",
+                  SSLClientSocket::NextProtoToString(negotiated_protocol));
   return std::move(dict);
 }
 
 HttpStreamFactoryImpl::Job::Job(Delegate* delegate,
                                 JobType job_type,
                                 HttpNetworkSession* session,
                                 const HttpRequestInfo& request_info,
                                 RequestPriority priority,
                                 const SSLConfig& server_ssl_config,
                                 const SSLConfig& proxy_ssl_config,
@@ skipping 52 matching lines @@
       negotiated_protocol_(kProtoUnknown),
       num_streams_(0),
       spdy_session_direct_(false),
       stream_type_(HttpStreamRequest::BIDIRECTIONAL_STREAM),
       ptr_factory_(this) {
   DCHECK(session);
   // The job can't have alternative service and alternative proxy server set at
   // the same time since alternative services are used for requests that are
   // fetched directly, while the alternative proxy server is used for requests
   // that should be fetched using proxy.
-  DCHECK(alternative_service_.protocol == kProtoUnknown ||
+  DCHECK(alternative_service_.protocol == UNINITIALIZED_ALTERNATE_PROTOCOL ||
          !alternative_proxy_server_.is_valid());
   DCHECK(!alternative_proxy_server_.is_valid() ||
          !(IsSpdyAlternative() || IsQuicAlternative()));
   // If either the alternative service protocol is specified or if the
   // alternative proxy server is valid, then the job type must be set to
   // either ALTERNATIVE or PRECONNECT.
-  DCHECK((alternative_service_.protocol == kProtoUnknown &&
+  DCHECK((alternative_service_.protocol == UNINITIALIZED_ALTERNATE_PROTOCOL &&
           !alternative_proxy_server_.is_valid()) ||
          (job_type_ == ALTERNATIVE || job_type_ == PRECONNECT));
   // If the alternative proxy server is valid, then the job type must be
   // set to ALTERNATIVE.
   DCHECK(!alternative_proxy_server_.is_valid() || job_type_ == ALTERNATIVE);
 
   if (IsSpdyAlternative()) {
     DCHECK(origin_url_.SchemeIs(url::kHttpsScheme));
   }
   if (IsQuicAlternative()) {
@@ skipping 1070 matching lines @@
     // We currently only support Alternate-Protocol where the original scheme
     // is http.
     // TODO(bnc): This comment is probably incorrect.
     DCHECK(origin_url_.SchemeIs(url::kHttpScheme));
     return origin_url_.SchemeIs(url::kHttpScheme);
   }
   return request_info_.url.SchemeIs(url::kHttpScheme);
 }
 
 bool HttpStreamFactoryImpl::Job::IsSpdyAlternative() const {
-  return alternative_service_.protocol == kProtoHTTP2;
+  return alternative_service_.protocol == NPN_HTTP_2;
 }
 
 bool HttpStreamFactoryImpl::Job::IsQuicAlternative() const {
-  return alternative_service_.protocol == kProtoQUIC;
+  return alternative_service_.protocol == QUIC;
 }
 
 void HttpStreamFactoryImpl::Job::InitSSLConfig(SSLConfig* ssl_config,
                                                bool is_proxy) const {
   if (!is_proxy) {
     // Prior to HTTP/2 and SPDY, some servers use TLS renegotiation to request
     // TLS client authentication after the HTTP request was sent. Allow
     // renegotiation for only those connections.
     //
     // Note that this does NOT implement the provision in
@@ skipping 171 matching lines @@
 
   ConnectionAttempts socket_attempts = connection_->connection_attempts();
   if (connection_->socket()) {
     connection_->socket()->GetConnectionAttempts(&socket_attempts);
   }
 
   delegate_->AddConnectionAttemptsToRequest(this, socket_attempts);
 }
 
 }  // namespace net