Add a template-specialized constructor for der::Input for constants

net/der/input.h

 // Copyright 2015 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.
 
 #ifndef NET_DER_INPUT_H_
 #define NET_DER_INPUT_H_
 
 #include <stdint.h>
 #include <string>
 
@@ skipping 23 matching lines @@
 // input: A ByteReader is copied and then is used to read some number of
 // bytes into the input, based on the content it is reading. A Mark can then be
 // set using the temporary ByteReader to indicate how far it read into the
 // Input. The original ByteReader can then be synchronized with how far the
 // temporary ByteReader read, by using either AdvanceToMark() or ReadToMark().
 class NET_EXPORT_PRIVATE Input {
  public:
   // Creates an empty Input, one from which no data can be read.
   Input();
 
+  // Creates an Input from a constant array |data|.
+  template <size_t N>
+  explicit Input(const uint8_t(&data)[N])
+      : data_(data), len_(N) {}
+
   // Creates an Input from the given |data| and |len|.
   Input(const uint8_t* data, size_t len);
 
   // Creates an Input from the given string |s|.
   explicit Input(const std::string& s);

[mattm, 2015/05/21 01:31:10]

It occurs to me that this constructor is kinda dangerous due to the std::string
implicit conversion constructors.

At first I was thinking about:
der::Input foo("te\0st");

which would do the wrong thing with std::string conversion parsing it as a null
terminated string. 

But then I realized it's even worse since the temporary std::string gets
destroyed immediately and the Input is pointing at freed memory.

Maybe we should also create an explicit char array constructor to avoid that?

[Ryan Sleevi, 2015/05/21 01:38:13]

Holy crap! You're totally right, and in fact all the usages that I can find are
explicitly wrong (from a memory-safety POV) because of this, because they're all
implicitly casting chars to strings.

Luckily, it's all unit tests, so we're not in danger, but yeah...

 
   // Returns the length in bytes of an Input's data.
   size_t Length() const { return len_; }
 
   // Return true if the Input's data and |other|'s data are byte-wise equal.
   bool Equals(const Input& other) const;
 
   // Returns a pointer to the Input's data. This method is marked as "unsafe"
   // because access to the Input's data should be done through ByteReader
   // instead. This method should only be used where using a ByteReader truly
@@ skipping 87 matching lines @@
   explicit Mark(const uint8_t* ptr);
   Mark();
   const uint8_t* ptr_;
 };
 
 }  // namespace der
 
 }  // namespace net
 
 #endif  // NET_DER_INPUT_H_