Remove dangerous std::string constructor for der::Input

net/der/input_unittest.cc

 // 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.
 
 #include "base/logging.h"
 #include "net/der/input.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 namespace der {
 namespace test {
 
 const uint8_t kInput[] = {'t', 'e', 's', 't'};
 
 TEST(InputTest, Equals) {
   Input test(kInput, arraysize(kInput));
   Input test2(kInput, arraysize(kInput));
   EXPECT_TRUE(test.Equals(test2));
 
-  std::string input_copy(reinterpret_cast<const char*>(kInput),
-                         arraysize(kInput));
+  uint8_t input_copy[arraysize(kInput)] = {0};
+  memcpy(input_copy, kInput, arraysize(kInput));

[Ryan Sleevi, 2015/05/26 18:53:30]

It's unclear what this is testing or why it's necessary

[nharper, 2015/05/26 22:11:49]

It's testing that 2 Inputs are equal that point to different data, but the
underlying data is the same. The above test (with test and test2) isn't enough
because they both point to the same underlying data kInput.

   Input test_copy(input_copy);
   EXPECT_TRUE(test.Equals(test_copy));
 
   Input test_truncated(kInput, arraysize(kInput) - 1);
   EXPECT_FALSE(test.Equals(test_truncated));
   EXPECT_FALSE(test_truncated.Equals(test));
 }
 
 TEST(InputTest, StaticArray) {
   Input input(kInput);
   EXPECT_EQ(arraysize(kInput), input.Length());
 
   Input input2(kInput, arraysize(kInput));
   EXPECT_TRUE(input.Equals(input2));
 }
 
+TEST(InputTest, FromCString) {
+  Input from_array(kInput);
+  Input from_string = Input::FromCString("test");
+  EXPECT_TRUE(from_array.Equals(from_string));
+
+  Input zero_length = Input::FromCString("");
+  EXPECT_EQ(0u, zero_length.Length());
+}
+
 TEST(ByteReaderTest, NoReadPastEnd) {
   ByteReader reader(Input(nullptr, 0));
   uint8_t data;
   EXPECT_FALSE(reader.ReadByte(&data));
 }
 
 TEST(ByteReaderTest, ReadToEnd) {
   uint8_t out;
   ByteReader reader(Input(kInput, arraysize(kInput)));
   for (size_t i = 0; i < arraysize(kInput); ++i) {
@@ skipping 30 matching lines @@
 
   // Reset the reader and check that we can read to a mark previously set.
   reader = ByteReader(input);
   Input marked_data;
   ASSERT_TRUE(reader.ReadToMark(mark, &marked_data));
 }
 
 TEST(ByteReaderTest, CantReadToWrongMark) {
   Input out;
   Input in1(kInput, arraysize(kInput));
-  Input in2("test");
+  Input in2 = Input::FromCString("test");
   ByteReader reader1(in1);
   ByteReader reader2(in2);
   ASSERT_TRUE(reader1.ReadBytes(2, &out));
   ASSERT_TRUE(reader2.ReadBytes(2, &out));
   Mark mark1 = reader1.NewMark();
   Mark mark2 = reader2.NewMark();
   reader1 = ByteReader(in1);
   reader2 = ByteReader(in2);
 
   // It is not possible to advance to a mark outside the underlying input.
@@ skipping 40 matching lines @@
   reader1 = ByteReader(in1);
   reader2 = ByteReader(in2);
 
   ASSERT_FALSE(reader1.AdvanceToMark(mark2));
   ASSERT_FALSE(reader2.AdvanceToMark(mark1));
 }
 
 }  // namespace test
 }  // namespace der
 }  // namespace net