Improve error handling of the transport security state generator.

net/tools/transport_security_state_generator/bit_writer.cc

 // Copyright (c) 2016 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/tools/transport_security_state_generator/bit_writer.h"
 
 #include "base/logging.h"
 
 namespace net {
 
@@ skipping 15 matching lines @@
   current_byte_ |= bit << (7 - used_);
   used_++;
   position_++;
 
   if (used_ == 8) {
     Flush();
   }
 }
 
 void BitWriter::Flush() {
+  position_ += (8 - used_);

[Ryan Sleevi, 2017/02/14 20:53:17]

This seems like a non-trivial behaviour change.

If I understand correctly, the old API contract was that you MUST write bits
along an 8 bit boundary (because they only flush on the 8th bit).

By introducing this, it allows partial advancement of non-aligned bits, except
for line 37 still writes fully aligned bits.

I'm not saying it's wrong; it just subtle and I'm hoping you can explain more
the motivation for this.

This also seems small enough that it could be its own CL, with the commit
description explaining this bug here?

[martijnc, 2017/02/15 22:07:58]

This doesn't change the API contract, both the old and the new code allow
writing of non-aligned bits over the byte boundary. The old code has a bug where
|position_| no longer matches the actual position after Flush() is called
because Flush() writes up to 8 bits to buffer but doesn't update |position_|.

The generator never writes to a BitWriter after it got flushed so doesn't hit
this bug, but it is possible so seems worth fixing.
Moved to https://codereview.chromium.org/2700433004

   bytes_.push_back(current_byte_);
 
   used_ = 0;
   current_byte_ = 0;
 }
 
-uint8_t BitWriter::BitLength(uint32_t input) const {
-  uint8_t number_of_bits = 0;
-  while (input != 0) {
-    number_of_bits++;
-    input >>= 1;
-  }
-  return number_of_bits;
-}
-
 }  // namespace transport_security_state
 
 }  // namespace net