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

sync/internal_api/public/base/unique_position.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 "sync/internal_api/public/base/unique_position.h"
 
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "sync/protocol/unique_position.pb.h"
 
@@ skipping 43 matching lines @@
     bytes[i] = static_cast<uint8>(y);
     y >>= 8;
   }
   return UniquePosition(bytes, suffix);
 }
 
 // static.
 UniquePosition UniquePosition::InitialPosition(
     const std::string& suffix) {
   DCHECK(IsValidSuffix(suffix));
-  return UniquePosition("", suffix);
+  return UniquePosition(std::string(), suffix);
 }
 
 // static.
 UniquePosition UniquePosition::Before(
     const UniquePosition& x,
     const std::string& suffix) {
   DCHECK(IsValidSuffix(suffix));
   DCHECK(x.IsValid());
   const std::string& before = FindSmallerWithSuffix(x.bytes_, suffix);
   return UniquePosition(before, suffix);
@@ skipping 93 matching lines @@
   size_t ref_zeroes = reference.find_first_not_of('\0');
   size_t suffix_zeroes = suffix.find_first_not_of('\0');
 
   // Neither of our inputs are allowed to have trailing zeroes, so the following
   // must be true.
   DCHECK_NE(ref_zeroes, std::string::npos);
   DCHECK_NE(suffix_zeroes, std::string::npos);
 
   if (suffix_zeroes > ref_zeroes) {
     // Implies suffix < ref.
-    return "";
+    return std::string();
   }
 
   if (suffix.substr(suffix_zeroes) < reference.substr(ref_zeroes)) {
     // Prepend zeroes so the result has as many zero digits as |reference|.
     return std::string(ref_zeroes - suffix_zeroes, '\0');
   } else if (suffix_zeroes > 1) {
     // Prepend zeroes so the result has one more zero digit than |reference|.
     // We could also take the "else" branch below, but taking this branch will
     // give us a smaller result.
     return std::string(ref_zeroes - suffix_zeroes + 1, '\0');
@@ skipping 14 matching lines @@
 
   if (ref_FFs == std::string::npos) {
     ref_FFs = reference.length();
   }
   if (suffix_FFs == std::string::npos) {
     suffix_FFs = suffix.length();
   }
 
   if (suffix_FFs > ref_FFs) {
     // Implies suffix > reference.
-    return "";
+    return std::string();
   }
 
   if (suffix.substr(suffix_FFs) > reference.substr(ref_FFs)) {
     // Prepend FF digits to match those in |reference|.
     return std::string(ref_FFs - suffix_FFs, kuint8max);
   } else if (suffix_FFs > 1) {
     // Prepend enough leading FF digits so result has one more of them than
     // |reference| does.  We could also take the "else" branch below, but this
     // gives us a smaller result.
     return std::string(ref_FFs - suffix_FFs + 1, kuint8max);
@@ skipping 13 matching lines @@
     const std::string& after,
     const std::string& suffix) {
   DCHECK(IsValidSuffix(suffix));
   DCHECK_NE(before, after);
   DCHECK_LT(before, after);
 
   std::string mid;
 
   // Sometimes our suffix puts us where we want to be.
   if (before < suffix && suffix < after) {
-    return "";
+    return std::string();
   }
 
   size_t i = 0;
   for ( ; i < std::min(before.length(), after.length()); ++i) {
     uint8 a_digit = before[i];
     uint8 b_digit = after[i];
 
     if (b_digit - a_digit >= 2) {
       mid.push_back(a_digit + (b_digit - a_digit)/2);
       return mid;
@@ skipping 61 matching lines @@
 UniquePosition::UniquePosition(
     const std::string& prefix,
     const std::string& suffix)
   : bytes_(prefix + suffix),
     is_valid_(IsValidBytes(bytes_)) {
   DCHECK(IsValidSuffix(suffix));
   DCHECK(IsValid());
 }
 
 }  // namespace syncer