Landing Recent QUIC changes until and including Mon Nov 16 14:15:48 2015

net/quic/quic_write_blocked_list.cc

 // Copyright 2014 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/quic_write_blocked_list.h"
 
 namespace net {
 
-const QuicPriority QuicWriteBlockedList::kHighestPriority =
-    static_cast<QuicPriority>(net::kHighestPriority);
-const QuicPriority QuicWriteBlockedList::kLowestPriority =
-    static_cast<QuicPriority>(net::kLowestPriority);
-
 QuicWriteBlockedList::QuicWriteBlockedList()
-    : crypto_stream_blocked_(false), headers_stream_blocked_(false) {
+    : last_priority_popped_(0),
+      crypto_stream_blocked_(false),
+      headers_stream_blocked_(false) {
+  memset(batch_write_stream_id_, 0,

[brucedawson, 2015/11/30 22:53:08]

This change is fragile and could be made simpler and more stable.

As it stands the two memset calls rely on knowledge of the type of the array
elements in order to verify their correctness. This dependency could be avoided
by replacing the explicit type with array[0]:

  memset(batch_write_stream_id_, 0,
           arraysize(batch_write_stream_id_) *
sizeof(batch_write_stream_id_[0]));

But even better would be this:

  memset(batch_write_stream_id_, 0, sizeof(batch_write_stream_id_));

Since arraysize divides by sizeof element and the lines of code are multiplying
by sizeof element it is simpler and safer to just use sizeof directly.

This was noticed because it triggered a VC++ /analyze warning about multiplying
sizeof() times sizeof() being suspicious.

+         arraysize(batch_write_stream_id_) * sizeof(QuicStreamId));
+  memset(bytes_left_for_batch_write_, 0,
+         arraysize(bytes_left_for_batch_write_) * sizeof(int32));
 }
 
 QuicWriteBlockedList::~QuicWriteBlockedList() {}
 
 }  // namespace net