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

chrome/browser/extensions/api/alarms/alarms_api_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.
 
 // This file tests the chrome.alarms extension API.
 
 #include "base/test/simple_test_clock.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/alarms/alarm_manager.h"
 #include "chrome/browser/extensions/api/alarms/alarms_api.h"
@@ skipping 133 matching lines @@
   scoped_refptr<extensions::Extension> extension_;
   content::WebContents* contents_;
 };
 
 TEST_F(ExtensionAlarmsTest, Create) {
   test_clock_.SetNow(base::Time::FromDoubleT(10));
   // Create 1 non-repeating alarm.
   CreateAlarm("[null, {\"delayInMinutes\": 0}]");
 
   const Alarm* alarm =
-      alarm_manager_->GetAlarm(extension_->id(), "");
+      alarm_manager_->GetAlarm(extension_->id(), std::string());
   ASSERT_TRUE(alarm);
   EXPECT_EQ("", alarm->js_alarm->name);
   EXPECT_DOUBLE_EQ(10000, alarm->js_alarm->scheduled_time);
   EXPECT_FALSE(alarm->js_alarm->period_in_minutes.get());
 
   // Now wait for the alarm to fire. Our test delegate will quit the
   // MessageLoop when that happens.
   MessageLoop::current()->Run();
 
   ASSERT_EQ(1u, alarm_delegate_->alarms_seen.size());
   EXPECT_EQ("", alarm_delegate_->alarms_seen[0]);
 
   // Ensure the alarm is gone.
   {
     const AlarmManager::AlarmList* alarms =
         alarm_manager_->GetAllAlarms(extension_->id());
     ASSERT_FALSE(alarms);
   }
 }
 
 TEST_F(ExtensionAlarmsTest, CreateRepeating) {
   test_clock_.SetNow(base::Time::FromDoubleT(10));
 
   // Create 1 repeating alarm.
   CreateAlarm("[null, {\"periodInMinutes\": 0.001}]");
 
   const Alarm* alarm =
-      alarm_manager_->GetAlarm(extension_->id(), "");
+      alarm_manager_->GetAlarm(extension_->id(), std::string());
   ASSERT_TRUE(alarm);
   EXPECT_EQ("", alarm->js_alarm->name);
   EXPECT_DOUBLE_EQ(10060, alarm->js_alarm->scheduled_time);
   EXPECT_THAT(alarm->js_alarm->period_in_minutes,
               testing::Pointee(testing::DoubleEq(0.001)));
 
   test_clock_.Advance(base::TimeDelta::FromSeconds(1));
   // Now wait for the alarm to fire. Our test delegate will quit the
   // MessageLoop when that happens.
   MessageLoop::current()->Run();
 
   test_clock_.Advance(base::TimeDelta::FromSeconds(1));
   // Wait again, and ensure the alarm fires again.
   alarm_manager_->ScheduleNextPoll();
   MessageLoop::current()->Run();
 
   ASSERT_EQ(2u, alarm_delegate_->alarms_seen.size());
   EXPECT_EQ("", alarm_delegate_->alarms_seen[0]);
 }
 
 TEST_F(ExtensionAlarmsTest, CreateAbsolute) {
   test_clock_.SetNow(base::Time::FromDoubleT(9.99));
   CreateAlarm("[null, {\"when\": 10001}]");
 
   const Alarm* alarm =
-      alarm_manager_->GetAlarm(extension_->id(), "");
+      alarm_manager_->GetAlarm(extension_->id(), std::string());
   ASSERT_TRUE(alarm);
   EXPECT_EQ("", alarm->js_alarm->name);
   EXPECT_DOUBLE_EQ(10001, alarm->js_alarm->scheduled_time);
   EXPECT_THAT(alarm->js_alarm->period_in_minutes,
               testing::IsNull());
 
   test_clock_.SetNow(base::Time::FromDoubleT(10.1));
   // Now wait for the alarm to fire. Our test delegate will quit the
   // MessageLoop when that happens.
   MessageLoop::current()->Run();
 
-  ASSERT_FALSE(alarm_manager_->GetAlarm(extension_->id(), ""));
+  ASSERT_FALSE(alarm_manager_->GetAlarm(extension_->id(), std::string()));
 
   ASSERT_EQ(1u, alarm_delegate_->alarms_seen.size());
   EXPECT_EQ("", alarm_delegate_->alarms_seen[0]);
 }
 
 TEST_F(ExtensionAlarmsTest, CreateRepeatingWithQuickFirstCall) {
   test_clock_.SetNow(base::Time::FromDoubleT(9.99));
   CreateAlarm("[null, {\"when\": 10001, \"periodInMinutes\": 0.001}]");
 
   const Alarm* alarm =
-      alarm_manager_->GetAlarm(extension_->id(), "");
+      alarm_manager_->GetAlarm(extension_->id(), std::string());
   ASSERT_TRUE(alarm);
   EXPECT_EQ("", alarm->js_alarm->name);
   EXPECT_DOUBLE_EQ(10001, alarm->js_alarm->scheduled_time);
   EXPECT_THAT(alarm->js_alarm->period_in_minutes,
               testing::Pointee(testing::DoubleEq(0.001)));
 
   test_clock_.SetNow(base::Time::FromDoubleT(10.1));
   // Now wait for the alarm to fire. Our test delegate will quit the
   // MessageLoop when that happens.
   MessageLoop::current()->Run();
 
-  ASSERT_TRUE(alarm_manager_->GetAlarm(extension_->id(), ""));
+  ASSERT_TRUE(alarm_manager_->GetAlarm(extension_->id(), std::string()));
   EXPECT_THAT(alarm_delegate_->alarms_seen, testing::ElementsAre(""));
 
   test_clock_.SetNow(base::Time::FromDoubleT(10.7));
   MessageLoop::current()->Run();
 
-  ASSERT_TRUE(alarm_manager_->GetAlarm(extension_->id(), ""));
+  ASSERT_TRUE(alarm_manager_->GetAlarm(extension_->id(), std::string()));
   EXPECT_THAT(alarm_delegate_->alarms_seen, testing::ElementsAre("", ""));
 }
 
 TEST_F(ExtensionAlarmsTest, CreateDupe) {
   test_clock_.SetNow(base::Time::FromDoubleT(10));
 
   // Create 2 duplicate alarms. The first should be overridden.
   CreateAlarm("[\"dup\", {\"delayInMinutes\": 1}]");
   CreateAlarm("[\"dup\", {\"delayInMinutes\": 7}]");
 
@@ skipping 252 matching lines @@
   EXPECT_TRUE(alarm_manager_->timer_.IsRunning());
   MessageLoop::current()->Run();
   EXPECT_FALSE(alarm_manager_->timer_.IsRunning());
   CreateAlarm("[\"bb\", {\"delayInMinutes\": 10}]");
   EXPECT_TRUE(alarm_manager_->timer_.IsRunning());
   alarm_manager_->RemoveAllAlarms(extension_->id());
   EXPECT_FALSE(alarm_manager_->timer_.IsRunning());
 }
 
 }  // namespace extensions