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

sync/internal_api/sync_encryption_handler_impl_unittest.cc

 // Copyright 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/sync_encryption_handler_impl.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/json/json_string_value_serializer.h"
@@ skipping 73 matching lines @@
   virtual void TearDown() {
     PumpLoop();
     test_user_share_.TearDown();
   }
 
  protected:
   void SetUpEncryption() {
     encryption_handler_.reset(
         new SyncEncryptionHandlerImpl(user_share(),
                                       &encryptor_,
-                                      "", ""  /* bootstrap tokens */));
+                                      std::string(),
+                                      std::string() /* bootstrap tokens */));
     encryption_handler_->AddObserver(&observer_);
   }
 
   void CreateRootForType(ModelType model_type) {
     syncer::syncable::Directory* directory = user_share()->directory.get();
 
     std::string tag_name = ModelTypeToRootTag(model_type);
 
     syncable::WriteTransaction wtrans(FROM_HERE, syncable::UNITTEST, directory);
     syncable::MutableEntry node(&wtrans,
@@ skipping 235 matching lines @@
 };
 
 // Verify that the encrypted types are being written to and read from the
 // nigori node properly.
 TEST_F(SyncEncryptionHandlerImplTest, NigoriEncryptionTypes) {
   sync_pb::NigoriSpecifics nigori;
 
   StrictMock<SyncEncryptionHandlerObserverMock> observer2;
   SyncEncryptionHandlerImpl handler2(user_share(),
                                      &encryptor_,
-                                     "", ""  /* bootstrap tokens */);
+                                     std::string(),
+                                     std::string() /* bootstrap tokens */);
   handler2.AddObserver(&observer2);
 
   // Just set the sensitive types (shouldn't trigger any notifications).
   ModelTypeSet encrypted_types(SyncEncryptionHandler::SensitiveTypes());
   {
     WriteTransaction trans(FROM_HERE, user_share());
     encryption_handler()->MergeEncryptedTypes(
         encrypted_types,
         trans.GetWrappedTrans());
     encryption_handler()->UpdateNigoriFromEncryptedTypes(
@@ skipping 243 matching lines @@
 // triggers a non-backwards compatible migration. Then verify that the
 // bootstrap token can be correctly parsed by the encryption handler at startup
 // time.
 TEST_F(SyncEncryptionHandlerImplTest, SetKeystoreMigratesAndUpdatesBootstrap) {
   // Passing no keys should do nothing.
   EXPECT_CALL(*observer(), OnBootstrapTokenUpdated(_, _)).Times(0);
   {
     WriteTransaction trans(FROM_HERE, user_share());
     EXPECT_FALSE(GetCryptographer()->is_initialized());
     EXPECT_TRUE(encryption_handler()->NeedKeystoreKey(trans.GetWrappedTrans()));
-    EXPECT_FALSE(
-        encryption_handler()->SetKeystoreKeys(BuildEncryptionKeyProto(""),
-                                              trans.GetWrappedTrans()));
+    EXPECT_FALSE(encryption_handler()->SetKeystoreKeys(
+        BuildEncryptionKeyProto(std::string()), trans.GetWrappedTrans()));
     EXPECT_TRUE(encryption_handler()->NeedKeystoreKey(trans.GetWrappedTrans()));
   }
   Mock::VerifyAndClearExpectations(observer());
 
   // Build a set of keystore keys.
   const char kRawOldKeystoreKey[] = "old_keystore_key";
   std::string old_keystore_key;
   base::Base64Encode(kRawOldKeystoreKey, &old_keystore_key);
   google::protobuf::RepeatedPtrField<google::protobuf::string> keys;
   keys.Add()->assign(kRawOldKeystoreKey);
@@ skipping 45 matching lines @@
   keystore_list->GetString(0, &test_string);
   ASSERT_EQ(old_keystore_key, test_string);
   keystore_list->GetString(1, &test_string);
   ASSERT_EQ(kKeystoreKey, test_string);
 
 
   // Now make sure a new encryption handler can correctly parse the bootstrap
   // token.
   SyncEncryptionHandlerImpl handler2(user_share(),
                                      &encryptor_,
-                                     "",  // Cryptographer bootstrap.
+                                     std::string(),  // Cryptographer bootstrap.
                                      keystore_bootstrap);
 
   {
     WriteTransaction trans(FROM_HERE, user_share());
     EXPECT_FALSE(handler2.NeedKeystoreKey(trans.GetWrappedTrans()));
   }
 }
 
 // Ensure GetKeystoreDecryptor only updates the keystore decryptor token if it
 // wasn't already set properly. Otherwise, the decryptor should remain the
@@ skipping 1579 matching lines @@
     encryption_handler()->SetKeystoreKeys(keys,
                                           trans.GetWrappedTrans());
   }
   PumpLoop();
   Mock::VerifyAndClearExpectations(observer());
 
   VerifyMigratedNigoriWithTimestamp(1, CUSTOM_PASSPHRASE, kCustomPass);
 }
 
 }  // namespace syncer