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

chrome/browser/value_store/leveldb_value_store.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 "chrome/browser/value_store/leveldb_value_store.h"
 
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
@@ skipping 316 matching lines @@
   }
   if (!status.ok())
     return WriteFailure("clear", status.ToString());
   return MakeWriteResult(changes.release());
 }
 
 std::string LeveldbValueStore::EnsureDbIsOpen() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   if (db_.get())
-    return "";
+    return std::string();
 
 #if defined(OS_POSIX)
   std::string os_path(db_path_.value());
 #elif defined(OS_WIN)
   std::string os_path = base::SysWideToUTF8(db_path_.value());
 #endif
 
   leveldb::Options options;
   options.create_if_missing = true;
   leveldb::DB* db;
   leveldb::Status status = leveldb::DB::Open(options, os_path, &db);
   if (!status.ok()) {
     // |os_path| may contain sensitive data, and these strings are passed
     // through to the extension, so strip that out.
     std::string status_string = status.ToString();
     ReplaceSubstringsAfterOffset(&status_string, 0u, os_path, "...");
     return base::StringPrintf("Failed to open database: %s",
                               status_string.c_str());
   }
 
   db_.reset(db);
-  return "";
+  return std::string();
 }
 
 std::string LeveldbValueStore::ReadFromDb(
     leveldb::ReadOptions options,
     const std::string& key,
     scoped_ptr<Value>* setting) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   DCHECK(setting != NULL);
   std::string value_as_json;
   leveldb::Status s = db_->Get(options, key, &value_as_json);
 
   if (s.IsNotFound()) {
     // Despite there being no value, it was still a success.
     // Check this first because ok() is false on IsNotFound.
-    return "";
+    return std::string();
   }
 
   if (!s.ok())
     return s.ToString();
 
   Value* value = base::JSONReader().ReadToValue(value_as_json);
   if (value == NULL) {
     // TODO(kalman): clear the offending non-JSON value from the database.
     return kInvalidJson;
   }
 
   setting->reset(value);
-  return "";
+  return std::string();
 }
 
 std::string LeveldbValueStore::AddToBatch(
     ValueStore::WriteOptions options,
     const std::string& key,
     const base::Value& value,
     leveldb::WriteBatch* batch,
     ValueStoreChangeList* changes) {
   scoped_ptr<Value> old_value;
   if (!(options & NO_CHECK_OLD_VALUE)) {
     std::string error = ReadFromDb(leveldb::ReadOptions(), key, &old_value);
     if (!error.empty())
       return error;
   }
 
   if (!old_value.get() || !old_value->Equals(&value)) {
     if (!(options & NO_GENERATE_CHANGES)) {
       changes->push_back(
           ValueStoreChange(key, old_value.release(), value.DeepCopy()));
     }
     std::string value_as_json;
     base::JSONWriter::Write(&value, &value_as_json);
     batch->Put(key, value_as_json);
   }
 
-  return "";
+  return std::string();
 }
 
 std::string LeveldbValueStore::WriteToDb(leveldb::WriteBatch* batch) {
   leveldb::Status status = db_->Write(leveldb::WriteOptions(), batch);
   if (status.IsNotFound()) {
     NOTREACHED() << "IsNotFound() but writing?!";
-    return "";
+    return std::string();
   }
-  return status.ok() ? "" : status.ToString();
+  return status.ok() ? std::string() : status.ToString();
 }
 
 bool LeveldbValueStore::IsEmpty() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   scoped_ptr<leveldb::Iterator> it(db_->NewIterator(leveldb::ReadOptions()));
 
   it->SeekToFirst();
   bool is_empty = !it->Valid();
   if (!it->status().ok()) {
     LOG(ERROR) << "Checking DB emptiness failed: " << it->status().ToString();
     return false;
   }
   return is_empty;
 }