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

chrome/test/chromedriver/server/http_handler_unittest.cc

 // Copyright (c) 2013 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 <string>
 
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "chrome/test/chromedriver/chrome/status.h"
@@ skipping 38 matching lines @@
   HttpResponse response;
   handler.Handle(request, &response);
   ASSERT_EQ(HttpResponse::kBadRequest, response.status());
 }
 
 TEST(HttpHandlerTest, HandleUnknownCommand) {
   HttpHandler handler(
       scoped_ptr<CommandExecutor>(new DummyExecutor()),
       scoped_ptr<HttpHandler::CommandMap>(new HttpHandler::CommandMap()),
       "/");
-  HttpRequest request(kGet, "/path", "");
+  HttpRequest request(kGet, "/path", std::string());
   HttpResponse response;
   handler.Handle(request, &response);
   ASSERT_EQ(HttpResponse::kNotFound, response.status());
 }
 
 TEST(HttpHandlerTest, HandleNewSession) {
   scoped_ptr<HttpHandler::CommandMap> map(new HttpHandler::CommandMap());
   map->push_back(CommandMapping(kPost, "session", CommandNames::kNewSession));
   HttpHandler handler(
       scoped_ptr<CommandExecutor>(new DummyExecutor()),
       map.Pass(), "/base/");
-  HttpRequest request(kPost, "/base/session", "");
+  HttpRequest request(kPost, "/base/session", std::string());
   HttpResponse response;
   handler.Handle(request, &response);
   ASSERT_EQ(HttpResponse::kSeeOther, response.status());
   std::string location;
   ASSERT_TRUE(response.GetHeader("Location", &location));
   std::string prefix = "/base/session/";
   ASSERT_EQ(prefix, location.substr(0, prefix.length()));
 }
 
 TEST(HttpHandlerTest, HandleInvalidPost) {
   scoped_ptr<HttpHandler::CommandMap> map(new HttpHandler::CommandMap());
   map->push_back(CommandMapping(kPost, "path", "cmd"));
   HttpHandler handler(
       scoped_ptr<CommandExecutor>(new DummyExecutor()),
       map.Pass(), "/");
   HttpRequest request(kPost, "/path", "should be a dictionary");
   HttpResponse response;
   handler.Handle(request, &response);
   ASSERT_EQ(HttpResponse::kBadRequest, response.status());
 }
 
 TEST(HttpHandlerTest, HandleUnimplementedCommand) {
   scoped_ptr<HttpHandler::CommandMap> map(new HttpHandler::CommandMap());
   map->push_back(CommandMapping(kPost, "path", "cmd"));
   HttpHandler handler(
       scoped_ptr<CommandExecutor>(new DummyExecutor(kUnknownCommand)),
       map.Pass(), "/");
-  HttpRequest request(kPost, "/path", "");
+  HttpRequest request(kPost, "/path", std::string());
   HttpResponse response;
   handler.Handle(request, &response);
   ASSERT_EQ(HttpResponse::kNotImplemented, response.status());
 }
 
 TEST(HttpHandlerTest, HandleCommand) {
   scoped_ptr<HttpHandler::CommandMap> map(new HttpHandler::CommandMap());
   map->push_back(CommandMapping(kPost, "path", "cmd"));
   HttpHandler handler(
       scoped_ptr<CommandExecutor>(new DummyExecutor()),
       map.Pass(), "/");
-  HttpRequest request(kPost, "/path", "");
+  HttpRequest request(kPost, "/path", std::string());
   HttpResponse response;
   handler.Handle(request, &response);
   ASSERT_EQ(HttpResponse::kOk, response.status());
   std::string mime;
   ASSERT_TRUE(response.GetHeader("Content-Type", &mime));
   base::DictionaryValue body;
   body.SetInteger("status", kOk);
   body.SetInteger("value", 1);
   body.SetString("sessionId", "session_id");
   std::string json;
@@ skipping 11 matching lines @@
   ASSERT_EQ(0u, params.size());
 }
 
 TEST(MatchesCommandTest, DiffPathLength) {
   CommandMapping command(kPost, "path/path", "command");
   std::string session_id;
   base::DictionaryValue params;
   ASSERT_FALSE(internal::MatchesCommand(
       kPost, "path", command, &session_id, &params));
   ASSERT_FALSE(internal::MatchesCommand(
-      kPost, "", command, &session_id, &params));
-  ASSERT_FALSE(internal::MatchesCommand(
-      kPost, "/", command, &session_id, &params));
+      kPost, std::string(), command, &session_id, &params));
+  ASSERT_FALSE(
+      internal::MatchesCommand(kPost, "/", command, &session_id, &params));
   ASSERT_FALSE(internal::MatchesCommand(
       kPost, "path/path/path", command, &session_id, &params));
 }
 
 TEST(MatchesCommandTest, DiffPaths) {
   CommandMapping command(kPost, "path/apath", "command");
   std::string session_id;
   base::DictionaryValue params;
   ASSERT_FALSE(internal::MatchesCommand(
       kPost, "path/bpath", command, &session_id, &params));
 }
 
 TEST(MatchesCommandTest, Substitution) {
   CommandMapping command(kPost, "path/:sessionId/space/:a/:b", "command");
   std::string session_id;
   base::DictionaryValue params;
   ASSERT_TRUE(internal::MatchesCommand(
       kPost, "path/1/space/2/3", command, &session_id, &params));
   ASSERT_EQ("1", session_id);
   ASSERT_EQ(2u, params.size());
   std::string param;
   ASSERT_TRUE(params.GetString("a", &param));
   ASSERT_EQ("2", param);
   ASSERT_TRUE(params.GetString("b", &param));
   ASSERT_EQ("3", param);
 }