Snapshot of all changes to get jumbo in blink and content.

net/quic/quartc/quartc_session.cc

 // Copyright (c) 2017 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/quic/quartc/quartc_session.h"
 
 #include "net/quic/platform/api/quic_ptr_util.h"
 
 using std::string;
 
 namespace net {
 
 namespace {
 
 // Default priority for incoming QUIC streams.
 // TODO(zhihuang): Determine if this value is correct.
-static const SpdyPriority kDefaultPriority = 3;
+static const SpdyPriority kDefaultSpdyPriority = 3;
 
 // Arbitrary server port number for net::QuicCryptoClientConfig.
 const int kQuicServerPort = 0;
 
 // Length of HKDF input keying material, equal to its number of bytes.
 // https://tools.ietf.org/html/rfc5869#section-2.2.
 // TODO(zhihuang): Verify that input keying material length is correct.
 const size_t kInputKeyingMaterialLength = 32;
 
 // Used by QuicCryptoServerConfig to provide dummy proof credentials.
@@ skipping 202 matching lines @@
   bool success = crypto_stream_->ExportKeyingMaterial(label, quic_context,
                                                       result_len, &quic_result);
   quic_result.copy(reinterpret_cast<char*>(result), result_len);
   DCHECK(quic_result.length() == result_len);
   return success;
 }
 
 QuartcStreamInterface* QuartcSession::CreateOutgoingStream(
     const OutgoingStreamParameters& param) {
   // The |param| is for forward-compatibility. Not used for now.
-  return CreateOutgoingDynamicStream(kDefaultPriority);
+  return CreateOutgoingDynamicStream(kDefaultSpdyPriority);
 }
 
 void QuartcSession::SetDelegate(
     QuartcSessionInterface::Delegate* session_delegate) {
   if (session_delegate_) {
     LOG(WARNING) << "The delegate for the session has already been set.";
   }
   session_delegate_ = session_delegate;
   DCHECK(session_delegate_);
 }
@@ skipping 25 matching lines @@
     QuicCryptoClientConfig* client_config) {
   quic_crypto_client_config_.reset(client_config);
 }
 
 void QuartcSession::SetServerCryptoConfig(
     QuicCryptoServerConfig* server_config) {
   quic_crypto_server_config_.reset(server_config);
 }
 
 QuicStream* QuartcSession::CreateIncomingDynamicStream(QuicStreamId id) {
-  return ActivateDataStream(CreateDataStream(id, kDefaultPriority));
+  return ActivateDataStream(CreateDataStream(id, kDefaultSpdyPriority));
 }
 
 std::unique_ptr<QuicStream> QuartcSession::CreateStream(QuicStreamId id) {
-  return CreateDataStream(id, kDefaultPriority);
+  return CreateDataStream(id, kDefaultSpdyPriority);
 }
 
 std::unique_ptr<QuartcStream> QuartcSession::CreateDataStream(
     QuicStreamId id,
     SpdyPriority priority) {
   if (crypto_stream_ == nullptr || !crypto_stream_->encryption_established()) {
     // Encryption not active so no stream created
     return nullptr;
   }
   auto stream = QuicMakeUnique<QuartcStream>(id, this);
@@ skipping 22 matching lines @@
   // Transfer ownership of the data stream to the session via ActivateStream().
   QuartcStream* raw = stream.release();
   if (raw) {
     // Make QuicSession take ownership of the stream.
     ActivateStream(std::unique_ptr<QuicStream>(raw));
   }
   return raw;
 }
 
 }  // namespace net