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

content/browser/download/base_file_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 "content/browser/download/base_file.h"
 
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 36 matching lines @@
   }
 
   virtual void SetUp() {
     ResetHash();
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     base_file_.reset(new BaseFile(base::FilePath(),
                                   GURL(),
                                   GURL(),
                                   0,
                                   false,
-                                  "",
+                                  std::string(),
                                   scoped_ptr<net::FileStream>(),
                                   net::BoundNetLog()));
   }
 
   virtual void TearDown() {
     EXPECT_FALSE(base_file_->in_progress());
     if (!expected_error_) {
       EXPECT_EQ(static_cast<int64>(expected_data_.size()),
                 base_file_->bytes_so_far());
     }
@@ skipping 30 matching lines @@
                 sizeof(sha256_hash_));
     return hash;
   }
 
   void MakeFileWithHash() {
     base_file_.reset(new BaseFile(base::FilePath(),
                                   GURL(),
                                   GURL(),
                                   0,
                                   true,
-                                  "",
+                                  std::string(),
                                   scoped_ptr<net::FileStream>(),
                                   net::BoundNetLog()));
   }
 
   bool InitializeFile() {
     DownloadInterruptReason result = base_file_->Initialize(temp_dir_.path());
     EXPECT_EQ(expected_error_, result);
     return result == DOWNLOAD_INTERRUPT_REASON_NONE;
   }
 
@@ skipping 19 matching lines @@
 
   // Helper functions.
   // Create a file.  Returns the complete file path.
   base::FilePath CreateTestFile() {
     base::FilePath file_name;
     BaseFile file(base::FilePath(),
                   GURL(),
                   GURL(),
                   0,
                   false,
-                  "",
+                  std::string(),
                   scoped_ptr<net::FileStream>(),
                   net::BoundNetLog());
 
     EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
               file.Initialize(temp_dir_.path()));
     file_name = file.full_path();
     EXPECT_NE(base::FilePath::StringType(), file_name.value());
 
     EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
               file.AppendDataToFile(kTestData4, kTestDataLength4));
 
     // Keep the file from getting deleted when existing_file_name is deleted.
     file.Detach();
 
     return file_name;
   }
 
   // Create a file with the specified file name.
   void CreateFileWithName(const base::FilePath& file_name) {
     EXPECT_NE(base::FilePath::StringType(), file_name.value());
     BaseFile duplicate_file(file_name,
                             GURL(),
                             GURL(),
                             0,
                             false,
-                            "",
+                            std::string(),
                             scoped_ptr<net::FileStream>(),
                             net::BoundNetLog());
     EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
               duplicate_file.Initialize(temp_dir_.path()));
     // Write something into it.
     duplicate_file.AppendDataToFile(kTestData4, kTestDataLength4);
     // Detach the file so it isn't deleted on destruction of |duplicate_file|.
     duplicate_file.Detach();
   }
 
@@ skipping 311 matching lines @@
                 base::PLATFORM_FILE_OPEN_ALWAYS | base::PLATFORM_FILE_WRITE));
 
   // Copy of mock_file_stream; we pass ownership and rely on the BaseFile
   // not deleting it until it is reset.
 
   base_file_.reset(new BaseFile(mock_file_stream->get_path(),
                                 GURL(),
                                 GURL(),
                                 0,
                                 false,
-                                "",
+                                std::string(),
                                 mock_file_stream_scoped_ptr.Pass(),
                                 net::BoundNetLog()));
   ASSERT_TRUE(InitializeFile());
   ASSERT_TRUE(AppendDataToFile(kTestData1));
   ASSERT_TRUE(AppendDataToFile(kTestData2));
   mock_file_stream->set_forced_error(net::ERR_ACCESS_DENIED);
   set_expected_error(DOWNLOAD_INTERRUPT_REASON_FILE_ACCESS_DENIED);
   ASSERT_FALSE(AppendDataToFile(kTestData3));
   std::string hash;
   EXPECT_FALSE(base_file_->GetHash(&hash));
@@ skipping 26 matching lines @@
   base::FilePath existing_file_name = CreateTestFile();
 
   set_expected_data(kTestData4);
 
   // Use the file we've just created.
   base_file_.reset(new BaseFile(existing_file_name,
                                 GURL(),
                                 GURL(),
                                 kTestDataLength4,
                                 false,
-                                "",
+                                std::string(),
                                 scoped_ptr<net::FileStream>(),
                                 net::BoundNetLog()));
 
   ASSERT_TRUE(InitializeFile());
 
   const base::FilePath file_name = base_file_->full_path();
   EXPECT_NE(base::FilePath::StringType(), file_name.value());
 
   // Write into the file.
   EXPECT_TRUE(AppendDataToFile(kTestData1));
@@ skipping 13 matching lines @@
 
   // Make it read-only.
   EXPECT_TRUE(file_util::MakeFileUnwritable(readonly_file_name));
 
   // Try to overwrite it.
   base_file_.reset(new BaseFile(readonly_file_name,
                                 GURL(),
                                 GURL(),
                                 0,
                                 false,
-                                "",
+                                std::string(),
                                 scoped_ptr<net::FileStream>(),
                                 net::BoundNetLog()));
 
   expect_in_progress_ = false;
   set_expected_error(DOWNLOAD_INTERRUPT_REASON_FILE_ACCESS_DENIED);
   EXPECT_FALSE(InitializeFile());
 
   const base::FilePath file_name = base_file_->full_path();
   EXPECT_NE(base::FilePath::StringType(), file_name.value());
 
   // Write into the file.
   set_expected_error(DOWNLOAD_INTERRUPT_REASON_FILE_FAILED);
   EXPECT_FALSE(AppendDataToFile(kTestData1));
 
   base_file_->Finish();
   base_file_->Detach();
   expect_file_survives_ = true;
 }
 
 TEST_F(BaseFileTest, IsEmptyHash) {
   std::string empty(BaseFile::kSha256HashLen, '\x00');
   EXPECT_TRUE(BaseFile::IsEmptyHash(empty));
   std::string not_empty(BaseFile::kSha256HashLen, '\x01');
   EXPECT_FALSE(BaseFile::IsEmptyHash(not_empty));
-  EXPECT_FALSE(BaseFile::IsEmptyHash(""));
+  EXPECT_FALSE(BaseFile::IsEmptyHash(std::string()));
 }
 
 // Test that calculating speed after no writes.
 TEST_F(BaseFileTest, SpeedWithoutWrite) {
   ASSERT_TRUE(InitializeFile());
   base::TimeTicks current = StartTick() + kElapsedTimeDelta;
   ASSERT_EQ(0, CurrentSpeedAtTime(current));
   base_file_->Finish();
 }
 
@@ skipping 42 matching lines @@
   base::FilePath temp_file;
   ASSERT_TRUE(file_util::CreateTemporaryFileInDir(temp_dir_.path(),
                                                   &temp_file));
   ASSERT_FALSE(temp_file.empty());
   EXPECT_STREQ(temp_file.DirName().value().c_str(),
                base_file_->full_path().DirName().value().c_str());
   base_file_->Finish();
 }
 
 }  // namespace content