s/NPN/ALPN/

net/http/http_stream_factory_impl_request.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_request.h"
 
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "net/http/bidirectional_stream_impl.h"
@@ skipping 12 matching lines @@
         websocket_handshake_stream_create_helper,
     const BoundNetLog& net_log,
     StreamType stream_type)
     : url_(url),
       helper_(helper),
       websocket_handshake_stream_create_helper_(
           websocket_handshake_stream_create_helper),
       delegate_(delegate),
       net_log_(net_log),
       completed_(false),
-      was_npn_negotiated_(false),
+      was_alpn_negotiated_(false),
       negotiated_protocol_(kProtoUnknown),
       using_spdy_(false),
       stream_type_(stream_type) {
   DCHECK(delegate_);
 
   net_log_.BeginEvent(NetLogEventType::HTTP_STREAM_REQUEST);
 }
 
 HttpStreamFactoryImpl::Request::~Request() {
   net_log_.EndEvent(NetLogEventType::HTTP_STREAM_REQUEST);
   helper_->OnRequestComplete();
 }
 
 void HttpStreamFactoryImpl::Request::SetSpdySessionKey(
     const SpdySessionKey& spdy_session_key) {
   spdy_session_key_.reset(new SpdySessionKey(spdy_session_key));
 }
 
-void HttpStreamFactoryImpl::Request::Complete(bool was_npn_negotiated,
+void HttpStreamFactoryImpl::Request::Complete(bool was_alpn_negotiated,
                                               NextProto negotiated_protocol,
                                               bool using_spdy) {
   DCHECK(!completed_);
   completed_ = true;
-  was_npn_negotiated_ = was_npn_negotiated;
+  was_alpn_negotiated_ = was_alpn_negotiated;
   negotiated_protocol_ = negotiated_protocol;
   using_spdy_ = using_spdy;
 }
 
 void HttpStreamFactoryImpl::Request::OnStreamReady(
     const SSLConfig& used_ssl_config,
     const ProxyInfo& used_proxy_info,
     HttpStream* stream) {
   DCHECK(completed_);
   delegate_->OnStreamReady(used_ssl_config, used_proxy_info, stream);
@@ skipping 60 matching lines @@
 }
 
 void HttpStreamFactoryImpl::Request::SetPriority(RequestPriority priority) {
   helper_->SetPriority(priority);
 }
 
 LoadState HttpStreamFactoryImpl::Request::GetLoadState() const {
   return helper_->GetLoadState();
 }
 
-bool HttpStreamFactoryImpl::Request::was_npn_negotiated() const {
+bool HttpStreamFactoryImpl::Request::was_alpn_negotiated() const {
   DCHECK(completed_);
-  return was_npn_negotiated_;
+  return was_alpn_negotiated_;
 }
 
 NextProto HttpStreamFactoryImpl::Request::negotiated_protocol() const {
   DCHECK(completed_);
   return negotiated_protocol_;
 }
 
 bool HttpStreamFactoryImpl::Request::using_spdy() const {
   DCHECK(completed_);
   return using_spdy_;
@@ skipping 14 matching lines @@
   return spdy_session_key_.get() != NULL;
 }
 
 void HttpStreamFactoryImpl::Request::AddConnectionAttempts(
     const ConnectionAttempts& attempts) {
   for (const auto& attempt : attempts)
     connection_attempts_.push_back(attempt);
 }
 
 }  // namespace net