Rewrite std::string("") to std::string(), Linux edition.

net/cookies/cookie_store_unittest.h

 // 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.
 
 #ifndef NET_COOKIES_COOKIE_STORE_UNITTEST_H_
 #define NET_COOKIES_COOKIE_STORE_UNITTEST_H_
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/strings/string_tokenizer.h"
@@ skipping 257 matching lines @@
 
   // Test setting a domain= that doesn't start w/ a dot, should
   // treat it as a domain cookie, as if there was a pre-pended dot.
   EXPECT_TRUE(this->SetCookie(cs, this->url_google_,
                               "G=H; domain=www.google.izzle"));
   this->MatchCookieLines("A=B; C=D; E=F; G=H",
                          this->GetCookies(cs, this->url_google_));
 
   // Test domain enforcement, should fail on a sub-domain or something too deep.
   EXPECT_FALSE(this->SetCookie(cs, this->url_google_, "I=J; domain=.izzle"));
-  this->MatchCookieLines("", this->GetCookies(cs, GURL("http://a.izzle")));
-  EXPECT_FALSE(this->SetCookie(cs, this->url_google_,
-                               "K=L; domain=.bla.www.google.izzle"));
+  this->MatchCookieLines(std::string(),
+                         this->GetCookies(cs, GURL("http://a.izzle")));
+  EXPECT_FALSE(this->SetCookie(
+      cs, this->url_google_, "K=L; domain=.bla.www.google.izzle"));
   this->MatchCookieLines("C=D; E=F; G=H",
       this->GetCookies(cs, GURL("http://bla.www.google.izzle")));
   this->MatchCookieLines("A=B; C=D; E=F; G=H",
       this->GetCookies(cs, this->url_google_));
 }
 
 // FireFox recognizes domains containing trailing periods as valid.
 // IE and Safari do not. Assert the expected policy here.
 TYPED_TEST_P(CookieStoreTest, DomainWithTrailingDotTest) {
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
   EXPECT_FALSE(this->SetCookie(cs, this->url_google_,
                                "a=1; domain=.www.google.com."));
   EXPECT_FALSE(this->SetCookie(cs, this->url_google_,
                                "b=2; domain=.www.google.com.."));
-  this->MatchCookieLines("", this->GetCookies(cs, this->url_google_));
+  this->MatchCookieLines(std::string(),
+                         this->GetCookies(cs, this->url_google_));
 }
 
 // Test that cookies can bet set on higher level domains.
 // http://b/issue?id=896491
 TYPED_TEST_P(CookieStoreTest, ValidSubdomainTest) {
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
   GURL url_abcd("http://a.b.c.d.com");
   GURL url_bcd("http://b.c.d.com");
   GURL url_cd("http://c.d.com");
   GURL url_d("http://d.com");
@@ skipping 53 matching lines @@
                                  "k=11; domain=.foo.bar.com?blah"));
     EXPECT_FALSE(this->SetCookie(cs, url_foobar,
                                  "l=12; domain=.foo.bar.com/blah"));
     EXPECT_FALSE(this->SetCookie(cs, url_foobar,
                                  "m=13; domain=.foo.bar.com:80"));
     EXPECT_FALSE(this->SetCookie(cs, url_foobar,
                                  "n=14; domain=.foo.bar.com:"));
     EXPECT_FALSE(this->SetCookie(cs, url_foobar,
                                  "o=15; domain=.foo.bar.com#sup"));
 
-    this->MatchCookieLines("", this->GetCookies(cs, url_foobar));
+    this->MatchCookieLines(std::string(), this->GetCookies(cs, url_foobar));
   }
 
   {
     // Make sure the cookie code hasn't gotten its subdomain string handling
     // reversed, missed a suffix check, etc.  It's important here that the two
     // hosts below have the same domain + registry.
     scoped_refptr<CookieStore> cs(this->GetCookieStore());
     GURL url_foocom("http://foo.com.com");
     EXPECT_FALSE(this->SetCookie(cs, url_foocom,
                                  "a=1; domain=.foo.com.com.com"));
-    this->MatchCookieLines("", this->GetCookies(cs, url_foocom));
+    this->MatchCookieLines(std::string(), this->GetCookies(cs, url_foocom));
   }
 }
 
 // Test the behavior of omitting dot prefix from domain, should
 // function the same as FireFox.
 // http://b/issue?id=889898
 TYPED_TEST_P(CookieStoreTest, DomainWithoutLeadingDotTest) {
   {  // The omission of dot results in setting a domain cookie.
     scoped_refptr<CookieStore> cs(this->GetCookieStore());
     GURL url_hosted("http://manage.hosted.filefront.com");
     GURL url_filefront("http://www.filefront.com");
     EXPECT_TRUE(this->SetCookie(cs, url_hosted,
                                 "sawAd=1; domain=filefront.com"));
     this->MatchCookieLines("sawAd=1", this->GetCookies(cs, url_hosted));
     this->MatchCookieLines("sawAd=1", this->GetCookies(cs, url_filefront));
   }
 
   {  // Even when the domains match exactly, don't consider it host cookie.
     scoped_refptr<CookieStore> cs(this->GetCookieStore());
     GURL url("http://www.google.com");
     EXPECT_TRUE(this->SetCookie(cs, url, "a=1; domain=www.google.com"));
     this->MatchCookieLines("a=1", this->GetCookies(cs, url));
     this->MatchCookieLines("a=1",
         this->GetCookies(cs, GURL("http://sub.www.google.com")));
-    this->MatchCookieLines("",
-        this->GetCookies(cs, GURL("http://something-else.com")));
+    this->MatchCookieLines(
+        std::string(), this->GetCookies(cs, GURL("http://something-else.com")));
   }
 }
 
 // Test that the domain specified in cookie string is treated case-insensitive
 // http://b/issue?id=896475.
 TYPED_TEST_P(CookieStoreTest, CaseInsensitiveDomainTest) {
     scoped_refptr<CookieStore> cs(this->GetCookieStore());
   GURL url("http://www.google.com");
   EXPECT_TRUE(this->SetCookie(cs, url, "a=1; domain=.GOOGLE.COM"));
   EXPECT_TRUE(this->SetCookie(cs, url, "b=2; domain=.wWw.gOOgLE.coM"));
   this->MatchCookieLines("a=1; b=2", this->GetCookies(cs, url));
 }
 
 TYPED_TEST_P(CookieStoreTest, TestIpAddress) {
   GURL url_ip("http://1.2.3.4/weee");
   {
     scoped_refptr<CookieStore> cs(this->GetCookieStore());
     EXPECT_TRUE(this->SetCookie(cs, url_ip, kValidCookieLine));
     this->MatchCookieLines("A=B", this->GetCookies(cs, url_ip));
   }
 
   {  // IP addresses should not be able to set domain cookies.
     scoped_refptr<CookieStore> cs(this->GetCookieStore());
     EXPECT_FALSE(this->SetCookie(cs, url_ip, "b=2; domain=.1.2.3.4"));
     EXPECT_FALSE(this->SetCookie(cs, url_ip, "c=3; domain=.3.4"));
-    this->MatchCookieLines("", this->GetCookies(cs, url_ip));
+    this->MatchCookieLines(std::string(), this->GetCookies(cs, url_ip));
     // It should be allowed to set a cookie if domain= matches the IP address
     // exactly.  This matches IE/Firefox, even though it seems a bit wrong.
     EXPECT_FALSE(this->SetCookie(cs, url_ip, "b=2; domain=1.2.3.3"));
-    this->MatchCookieLines("", this->GetCookies(cs, url_ip));
+    this->MatchCookieLines(std::string(), this->GetCookies(cs, url_ip));
     EXPECT_TRUE(this->SetCookie(cs, url_ip, "b=2; domain=1.2.3.4"));
     this->MatchCookieLines("b=2", this->GetCookies(cs, url_ip));
   }
 }
 
 // Test host cookies, and setting of cookies on TLD.
 TYPED_TEST_P(CookieStoreTest, TestNonDottedAndTLD) {
   {
     scoped_refptr<CookieStore> cs(this->GetCookieStore());
     GURL url("http://com/");
     // Allow setting on "com", (but only as a host cookie).
     EXPECT_TRUE(this->SetCookie(cs, url, "a=1"));
     EXPECT_FALSE(this->SetCookie(cs, url, "b=2; domain=.com"));
     EXPECT_FALSE(this->SetCookie(cs, url, "c=3; domain=com"));
     this->MatchCookieLines("a=1", this->GetCookies(cs, url));
     // Make sure it doesn't show up for a normal .com, it should be a host
     // not a domain cookie.
-    this->MatchCookieLines("",
+    this->MatchCookieLines(
+        std::string(),
         this->GetCookies(cs, GURL("http://hopefully-no-cookies.com/")));
     if (TypeParam::supports_non_dotted_domains) {
-      this->MatchCookieLines("", this->GetCookies(cs, GURL("http://.com/")));
+      this->MatchCookieLines(std::string(),
+                             this->GetCookies(cs, GURL("http://.com/")));
     }
   }
 
   {
     // http://com. should be treated the same as http://com.
     scoped_refptr<CookieStore> cs(this->GetCookieStore());
     GURL url("http://com./index.html");
     if (TypeParam::supports_trailing_dots) {
       EXPECT_TRUE(this->SetCookie(cs, url, "a=1"));
       this->MatchCookieLines("a=1", this->GetCookies(cs, url));
-      this->MatchCookieLines("",
+      this->MatchCookieLines(
+          std::string(),
           this->GetCookies(cs, GURL("http://hopefully-no-cookies.com./")));
     } else {
       EXPECT_FALSE(this->SetCookie(cs, url, "a=1"));
     }
   }
 
   {  // Should not be able to set host cookie from a subdomain.
     scoped_refptr<CookieStore> cs(this->GetCookieStore());
     GURL url("http://a.b");
     EXPECT_FALSE(this->SetCookie(cs, url, "a=1; domain=.b"));
     EXPECT_FALSE(this->SetCookie(cs, url, "b=2; domain=b"));
-    this->MatchCookieLines("", this->GetCookies(cs, url));
+    this->MatchCookieLines(std::string(), this->GetCookies(cs, url));
   }
 
   {  // Same test as above, but explicitly on a known TLD (com).
     scoped_refptr<CookieStore> cs(this->GetCookieStore());
     GURL url("http://google.com");
     EXPECT_FALSE(this->SetCookie(cs, url, "a=1; domain=.com"));
     EXPECT_FALSE(this->SetCookie(cs, url, "b=2; domain=com"));
-    this->MatchCookieLines("", this->GetCookies(cs, url));
+    this->MatchCookieLines(std::string(), this->GetCookies(cs, url));
   }
 
   {  // Make sure can't set cookie on TLD which is dotted.
     scoped_refptr<CookieStore> cs(this->GetCookieStore());
     GURL url("http://google.co.uk");
     EXPECT_FALSE(this->SetCookie(cs, url, "a=1; domain=.co.uk"));
     EXPECT_FALSE(this->SetCookie(cs, url, "b=2; domain=.uk"));
-    this->MatchCookieLines("", this->GetCookies(cs, url));
-    this->MatchCookieLines("",
+    this->MatchCookieLines(std::string(), this->GetCookies(cs, url));
+    this->MatchCookieLines(
+        std::string(),
         this->GetCookies(cs, GURL("http://something-else.co.uk")));
-    this->MatchCookieLines("",
-        this->GetCookies(cs, GURL("http://something-else.uk")));
+    this->MatchCookieLines(
+        std::string(), this->GetCookies(cs, GURL("http://something-else.uk")));
   }
 
   {  // Intranet URLs should only be able to set host cookies.
     scoped_refptr<CookieStore> cs(this->GetCookieStore());
     GURL url("http://b");
     EXPECT_TRUE(this->SetCookie(cs, url, "a=1"));
     EXPECT_FALSE(this->SetCookie(cs, url, "b=2; domain=.b"));
     EXPECT_FALSE(this->SetCookie(cs, url, "c=3; domain=b"));
     this->MatchCookieLines("a=1", this->GetCookies(cs, url));
   }
@@ skipping 15 matching lines @@
     this->MatchCookieLines("a=1", this->GetCookies(cs, url));
 
     EXPECT_TRUE(this->SetCookie(cs, url_with_dot, "b=2; domain=.google.com."));
     this->MatchCookieLines("b=2", this->GetCookies(cs, url_with_dot));
   } else {
     EXPECT_TRUE(this->SetCookie(cs, url, "b=2; domain=.www.google.com."));
     EXPECT_FALSE(this->SetCookie(cs, url_with_dot, "b=2; domain=.google.com."));
   }
 
   // Make sure there weren't any side effects.
-  this->MatchCookieLines("",
+  this->MatchCookieLines(
+      std::string(),
       this->GetCookies(cs, GURL("http://hopefully-no-cookies.com/")));
-  this->MatchCookieLines("", this->GetCookies(cs, GURL("http://.com/")));
+  this->MatchCookieLines(std::string(),
+                         this->GetCookies(cs, GURL("http://.com/")));
 }
 
 TYPED_TEST_P(CookieStoreTest, InvalidScheme) {
   if (!TypeParam::filters_schemes)
     return;
 
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
   EXPECT_FALSE(this->SetCookie(cs, GURL(kUrlFtp), kValidCookieLine));
 }
 
 TYPED_TEST_P(CookieStoreTest, InvalidScheme_Read) {
   if (!TypeParam::filters_schemes)
     return;
 
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
   EXPECT_TRUE(this->SetCookie(cs, GURL(kUrlGoogle), kValidDomainCookieLine));
-  this->MatchCookieLines("", this->GetCookies(cs, GURL(kUrlFtp)));
+  this->MatchCookieLines(std::string(), this->GetCookies(cs, GURL(kUrlFtp)));
 }
 
 TYPED_TEST_P(CookieStoreTest, PathTest) {
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
   std::string url("http://www.google.izzle");
   EXPECT_TRUE(this->SetCookie(cs, GURL(url), "A=B; path=/wee"));
   this->MatchCookieLines("A=B", this->GetCookies(cs, GURL(url + "/wee")));
   this->MatchCookieLines("A=B", this->GetCookies(cs, GURL(url + "/wee/")));
   this->MatchCookieLines("A=B", this->GetCookies(cs, GURL(url + "/wee/war")));
   this->MatchCookieLines("A=B",
       this->GetCookies(cs, GURL(url + "/wee/war/more/more")));
   if (!TypeParam::has_path_prefix_bug)
-    this->MatchCookieLines("", this->GetCookies(cs, GURL(url + "/weehee")));
-  this->MatchCookieLines("", this->GetCookies(cs, GURL(url + "/")));
+    this->MatchCookieLines(std::string(),
+                           this->GetCookies(cs, GURL(url + "/weehee")));
+  this->MatchCookieLines(std::string(), this->GetCookies(cs, GURL(url + "/")));
 
   // If we add a 0 length path, it should default to /
   EXPECT_TRUE(this->SetCookie(cs, GURL(url), "A=C; path="));
   this->MatchCookieLines("A=B; A=C", this->GetCookies(cs, GURL(url + "/wee")));
   this->MatchCookieLines("A=C", this->GetCookies(cs, GURL(url + "/")));
 }
 
 TYPED_TEST_P(CookieStoreTest, EmptyExpires) {
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
   CookieOptions options;
@@ skipping 25 matching lines @@
 
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
   CookieOptions options;
   options.set_include_httponly();
 
   // Create a httponly cookie.
   EXPECT_TRUE(this->SetCookieWithOptions(cs, this->url_google_, "A=B; httponly",
                                          options));
 
   // Check httponly read protection.
-  this->MatchCookieLines("", this->GetCookies(cs, this->url_google_));
-  this->MatchCookieLines("A=B",
-      this->GetCookiesWithOptions(cs, this->url_google_, options));
+  this->MatchCookieLines(std::string(),
+                         this->GetCookies(cs, this->url_google_));
+  this->MatchCookieLines(
+      "A=B", this->GetCookiesWithOptions(cs, this->url_google_, options));
 
   // Check httponly overwrite protection.
   EXPECT_FALSE(this->SetCookie(cs, this->url_google_, "A=C"));
-  this->MatchCookieLines("", this->GetCookies(cs, this->url_google_));
-  this->MatchCookieLines("A=B",
-      this->GetCookiesWithOptions(cs, this->url_google_, options));
+  this->MatchCookieLines(std::string(),
+                         this->GetCookies(cs, this->url_google_));
+  this->MatchCookieLines(
+      "A=B", this->GetCookiesWithOptions(cs, this->url_google_, options));
   EXPECT_TRUE(this->SetCookieWithOptions(cs, this->url_google_, "A=C",
                                          options));
   this->MatchCookieLines("A=C", this->GetCookies(cs, this->url_google_));
 
   // Check httponly create protection.
   EXPECT_FALSE(this->SetCookie(cs, this->url_google_, "B=A; httponly"));
   this->MatchCookieLines("A=C",
       this->GetCookiesWithOptions(cs, this->url_google_, options));
   EXPECT_TRUE(this->SetCookieWithOptions(cs, this->url_google_, "B=A; httponly",
                                          options));
   this->MatchCookieLines("A=C; B=A",
       this->GetCookiesWithOptions(cs, this->url_google_, options));
   this->MatchCookieLines("A=C", this->GetCookies(cs, this->url_google_));
 }
 
 TYPED_TEST_P(CookieStoreTest, TestCookieDeletion) {
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
 
   // Create a session cookie.
   EXPECT_TRUE(this->SetCookie(cs, this->url_google_, kValidCookieLine));
   this->MatchCookieLines("A=B", this->GetCookies(cs, this->url_google_));
   // Delete it via Max-Age.
   EXPECT_TRUE(this->SetCookie(cs, this->url_google_,
                               std::string(kValidCookieLine) + "; max-age=0"));
-  this->MatchCookieLineWithTimeout(cs, this->url_google_, "");
+  this->MatchCookieLineWithTimeout(cs, this->url_google_, std::string());
 
   // Create a session cookie.
   EXPECT_TRUE(this->SetCookie(cs, this->url_google_, kValidCookieLine));
   this->MatchCookieLines("A=B", this->GetCookies(cs, this->url_google_));
   // Delete it via Expires.
   EXPECT_TRUE(this->SetCookie(cs, this->url_google_,
                               std::string(kValidCookieLine) +
                               "; expires=Mon, 18-Apr-1977 22:50:13 GMT"));
-  this->MatchCookieLines("", this->GetCookies(cs, this->url_google_));
+  this->MatchCookieLines(std::string(),
+                         this->GetCookies(cs, this->url_google_));
 
   // Create a persistent cookie.
   EXPECT_TRUE(this->SetCookie(cs, this->url_google_,
                               std::string(kValidCookieLine) +
                               "; expires=Mon, 18-Apr-22 22:50:13 GMT"));
 
   this->MatchCookieLines("A=B", this->GetCookies(cs, this->url_google_));
   // Delete it via Max-Age.
   EXPECT_TRUE(this->SetCookie(cs, this->url_google_,
                               std::string(kValidCookieLine) + "; max-age=0"));
-  this->MatchCookieLineWithTimeout(cs, this->url_google_, "");
+  this->MatchCookieLineWithTimeout(cs, this->url_google_, std::string());
 
   // Create a persistent cookie.
   EXPECT_TRUE(this->SetCookie(cs, this->url_google_,
                               std::string(kValidCookieLine) +
                               "; expires=Mon, 18-Apr-22 22:50:13 GMT"));
   this->MatchCookieLines("A=B", this->GetCookies(cs, this->url_google_));
   // Delete it via Expires.
   EXPECT_TRUE(this->SetCookie(cs, this->url_google_,
                               std::string(kValidCookieLine) +
                               "; expires=Mon, 18-Apr-1977 22:50:13 GMT"));
-  this->MatchCookieLines("", this->GetCookies(cs, this->url_google_));
+  this->MatchCookieLines(std::string(),
+                         this->GetCookies(cs, this->url_google_));
 
   // Create a persistent cookie.
   EXPECT_TRUE(this->SetCookie(cs, this->url_google_,
                               std::string(kValidCookieLine) +
                               "; expires=Mon, 18-Apr-22 22:50:13 GMT"));
   this->MatchCookieLines("A=B", this->GetCookies(cs, this->url_google_));
   // Check that it is not deleted with significant enough clock skew.
   base::Time server_time;
   EXPECT_TRUE(base::Time::FromString("Sun, 17-Apr-1977 22:50:13 GMT",
                                      &server_time));
   EXPECT_TRUE(this->SetCookieWithServerTime(
       cs, this->url_google_,
       std::string(kValidCookieLine) +
       "; expires=Mon, 18-Apr-1977 22:50:13 GMT",
       server_time));
   this->MatchCookieLines("A=B", this->GetCookies(cs, this->url_google_));
 
   // Create a persistent cookie.
   EXPECT_TRUE(this->SetCookie(cs, this->url_google_,
                               std::string(kValidCookieLine) +
                               "; expires=Mon, 18-Apr-22 22:50:13 GMT"));
   this->MatchCookieLines("A=B", this->GetCookies(cs, this->url_google_));
   // Delete it via Expires, with a unix epoch of 0.
   EXPECT_TRUE(this->SetCookie(cs, this->url_google_,
                               std::string(kValidCookieLine) +
                               "; expires=Thu, 1-Jan-1970 00:00:00 GMT"));
-  this->MatchCookieLines("", this->GetCookies(cs, this->url_google_));
+  this->MatchCookieLines(std::string(),
+                         this->GetCookies(cs, this->url_google_));
 }
 
 TYPED_TEST_P(CookieStoreTest, TestDeleteAllCreatedBetween) {
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
   const base::Time last_month = base::Time::Now() -
                                 base::TimeDelta::FromDays(30);
   const base::Time last_minute = base::Time::Now() -
                                  base::TimeDelta::FromMinutes(1);
   const base::Time next_minute = base::Time::Now() +
                                  base::TimeDelta::FromMinutes(1);
   const base::Time next_month = base::Time::Now() +
                                 base::TimeDelta::FromDays(30);
 
   // Add a cookie.
   EXPECT_TRUE(this->SetCookie(cs, this->url_google_, "A=B"));
    // Check that the cookie is in the store.
   this->MatchCookieLines("A=B", this->GetCookies(cs, this->url_google_));
 
   // Remove cookies in empty intervals.
   EXPECT_EQ(0, this->DeleteCreatedBetween(cs, last_month, last_minute));
   EXPECT_EQ(0, this->DeleteCreatedBetween(cs, next_minute, next_month));
   // Check that the cookie is still there.
   this->MatchCookieLines("A=B", this->GetCookies(cs, this->url_google_));
 
   // Remove the cookie with an interval defined by two dates.
   EXPECT_EQ(1, this->DeleteCreatedBetween(cs, last_minute, next_minute));
   // Check that the cookie disappeared.
-  this->MatchCookieLines("", this->GetCookies(cs, this->url_google_));
+  this->MatchCookieLines(std::string(),
+                         this->GetCookies(cs, this->url_google_));
 
   // Add another cookie.
   EXPECT_TRUE(this->SetCookie(cs, this->url_google_, "C=D"));
   // Check that the cookie is in the store.
   this->MatchCookieLines("C=D", this->GetCookies(cs, this->url_google_));
 
   // Remove the cookie with a null ending time.
   EXPECT_EQ(1, this->DeleteCreatedBetween(cs, last_minute, base::Time()));
   // Check that the cookie disappeared.
-  this->MatchCookieLines("", this->GetCookies(cs, this->url_google_));
+  this->MatchCookieLines(std::string(),
+                         this->GetCookies(cs, this->url_google_));
 }
 
 TYPED_TEST_P(CookieStoreTest, TestSecure) {
     scoped_refptr<CookieStore> cs(this->GetCookieStore());
 
   EXPECT_TRUE(this->SetCookie(cs, this->url_google_, "A=B"));
   this->MatchCookieLines("A=B", this->GetCookies(cs, this->url_google_));
   this->MatchCookieLines("A=B", this->GetCookies(cs, this->url_google_secure_));
 
   EXPECT_TRUE(this->SetCookie(cs, this->url_google_secure_, "A=B; secure"));
   // The secure should overwrite the non-secure.
-  this->MatchCookieLines("", this->GetCookies(cs, this->url_google_));
+  this->MatchCookieLines(std::string(),
+                         this->GetCookies(cs, this->url_google_));
   this->MatchCookieLines("A=B", this->GetCookies(cs, this->url_google_secure_));
 
   EXPECT_TRUE(this->SetCookie(cs, this->url_google_secure_, "D=E; secure"));
-  this->MatchCookieLines("", this->GetCookies(cs, this->url_google_));
+  this->MatchCookieLines(std::string(),
+                         this->GetCookies(cs, this->url_google_));
   this->MatchCookieLines("A=B; D=E",
                          this->GetCookies(cs, this->url_google_secure_));
 
   EXPECT_TRUE(this->SetCookie(cs, this->url_google_secure_, "A=B"));
   // The non-secure should overwrite the secure.
   this->MatchCookieLines("A=B", this->GetCookies(cs, this->url_google_));
   this->MatchCookieLines("D=E; A=B",
                          this->GetCookies(cs, this->url_google_secure_));
 }
 
@@ skipping 288 matching lines @@
 REGISTER_TYPED_TEST_CASE_P(MultiThreadedCookieStoreTest,
                            ThreadCheckGetCookies,
                            ThreadCheckGetCookiesWithOptions,
                            ThreadCheckSetCookieWithOptions,
                            ThreadCheckDeleteCookie,
                            ThreadCheckDeleteSessionCookies);
 
 }  // namespace net
 
 #endif  // NET_COOKIES_COOKIE_STORE_UNITTEST_H_