Use string(StringPiece) instead of StringPiece::as_string().

base/strings/string_piece_unittest.cc

 // Copyright (c) 2012 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 <stddef.h>
 
 #include <string>
 
 #include "base/strings/string16.h"
 #include "base/strings/string_piece.h"
@@ skipping 277 matching lines @@
   ASSERT_EQ(a.rfind(b), 0U);
   ASSERT_EQ(a.rfind(b, 1), 0U);
   ASSERT_EQ(a.rfind(c), 23U);
   ASSERT_EQ(a.rfind(c, 22U), Piece::npos);
   ASSERT_EQ(a.rfind(c, 1U), Piece::npos);
   ASSERT_EQ(a.rfind(c, 0U), Piece::npos);
   ASSERT_EQ(b.rfind(c), Piece::npos);
   ASSERT_EQ(b.rfind(c, 0U), Piece::npos);
   ASSERT_EQ(a.rfind(d), static_cast<size_t>(a.as_string().rfind(TypeParam())));
   ASSERT_EQ(a.rfind(e), a.as_string().rfind(TypeParam()));
+  ASSERT_EQ(a.rfind(d), static_cast<size_t>(TypeParam(a).rfind(TypeParam())));
+  ASSERT_EQ(a.rfind(e), TypeParam(a).rfind(TypeParam()));
   ASSERT_EQ(a.rfind(d, 12), 12U);
   ASSERT_EQ(a.rfind(e, 17), 17U);
   ASSERT_EQ(a.rfind(g), Piece::npos);
   ASSERT_EQ(d.rfind(b), Piece::npos);
   ASSERT_EQ(e.rfind(b), Piece::npos);
   ASSERT_EQ(d.rfind(b, 4), Piece::npos);
   ASSERT_EQ(e.rfind(b, 7), Piece::npos);
   // empty string nonsense
   ASSERT_EQ(d.rfind(d, 4), std::string().rfind(std::string()));
   ASSERT_EQ(e.rfind(d, 7), std::string().rfind(std::string()));
@@ skipping 203 matching lines @@
   c.set(foobar.c_str(), 0);
   ASSERT_EQ(c, e);
   c.set(foobar.c_str(), 7);  // Note, has an embedded NULL
   ASSERT_NE(c, a);
 
   // as_string
   TypeParam s3(a.as_string().c_str(), 7);  // Note, has an embedded NULL
   ASSERT_TRUE(c == s3);
   TypeParam s4(e.as_string());
   ASSERT_TRUE(s4.empty());
+
+  // operator STRING_TYPE()
+  TypeParam s5(TypeParam(a).c_str(), 7);  // Note, has an embedded NULL
+  ASSERT_TRUE(c == s5);
+  TypeParam s6(e);
+  ASSERT_TRUE(s6.empty());
 }
 
 TEST(StringPieceTest, CheckCustom) {
   StringPiece a("foobar");
   std::string s1("123");
   s1 += '\0';
   s1 += "456";
   StringPiece b(s1);
   StringPiece e;
   std::string s2;
@@ skipping 53 matching lines @@
 TYPED_TEST(CommonStringPieceTest, CheckNULL) {
   // we used to crash here, but now we don't.
   BasicStringPiece<TypeParam> s(NULL);
   ASSERT_EQ(s.data(), (const typename TypeParam::value_type*)NULL);
   ASSERT_EQ(s.size(), 0U);
 
   s.set(NULL);
   ASSERT_EQ(s.data(), (const typename TypeParam::value_type*)NULL);
   ASSERT_EQ(s.size(), 0U);
 
-  TypeParam str = s.as_string();
+  TypeParam str(s);
+  ASSERT_EQ(str.length(), 0U);
+  ASSERT_EQ(str, TypeParam());
+
+  str = s.as_string();
   ASSERT_EQ(str.length(), 0U);
   ASSERT_EQ(str, TypeParam());
 }
 
 TYPED_TEST(CommonStringPieceTest, CheckComparisons2) {
   TypeParam alphabet(TestFixture::as_string("abcdefghijklmnopqrstuvwxyz"));
   TypeParam alphabet_z(TestFixture::as_string("abcdefghijklmnopqrstuvwxyzz"));
   TypeParam alphabet_y(TestFixture::as_string("abcdefghijklmnopqrstuvwxyy"));
   BasicStringPiece<TypeParam> abc(alphabet);
 
@@ skipping 77 matching lines @@
   ASSERT_TRUE(empty == BasicStringPiece<TypeParam>(NULL,
       static_cast<typename BasicStringPiece<TypeParam>::size_type>(0)));
   ASSERT_TRUE(empty == BasicStringPiece<TypeParam>());
   ASSERT_TRUE(str == BasicStringPiece<TypeParam>(str.begin(), str.end()));
   ASSERT_TRUE(empty == BasicStringPiece<TypeParam>(str.begin(), str.begin()));
   ASSERT_TRUE(empty == BasicStringPiece<TypeParam>(empty));
   ASSERT_TRUE(empty == BasicStringPiece<TypeParam>(empty.begin(), empty.end()));
 }
 
 }  // namespace base