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

net/url_request/url_request_throttler_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 "net/url_request/url_request_throttler_manager.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/metrics/statistics_recorder.h"
@@ skipping 19 matching lines @@
 
 using base::Histogram;
 using base::HistogramBase;
 using base::HistogramSamples;
 using base::StatisticsRecorder;
 
 class MockURLRequestThrottlerEntry : public URLRequestThrottlerEntry {
  public:
   explicit MockURLRequestThrottlerEntry(
       net::URLRequestThrottlerManager* manager)
-      : net::URLRequestThrottlerEntry(manager, ""),
+      : net::URLRequestThrottlerEntry(manager, std::string()),
         mock_backoff_entry_(&backoff_policy_) {
     InitPolicy();
   }
   MockURLRequestThrottlerEntry(
       net::URLRequestThrottlerManager* manager,
       const TimeTicks& exponential_backoff_release_time,
       const TimeTicks& sliding_window_release_time,
       const TimeTicks& fake_now)
-      : net::URLRequestThrottlerEntry(manager, ""),
+      : net::URLRequestThrottlerEntry(manager, std::string()),
         fake_time_now_(fake_now),
         mock_backoff_entry_(&backoff_policy_) {
     InitPolicy();
 
     mock_backoff_entry_.set_fake_now(fake_now);
     set_exponential_backoff_release_time(exponential_backoff_release_time);
     set_sliding_window_release_time(sliding_window_release_time);
   }
 
   void InitPolicy() {
@@ skipping 212 matching lines @@
       entry_->fake_time_now_ - TimeDelta::FromMilliseconds(1));
   EXPECT_FALSE(entry_->ShouldRejectRequest(request_));
 
   CalculateHistogramDeltas();
   ASSERT_EQ(2, samples_["Throttling.RequestThrottled"]->GetCount(0));
   ASSERT_EQ(0, samples_["Throttling.RequestThrottled"]->GetCount(1));
 }
 
 TEST_F(URLRequestThrottlerEntryTest, InterfaceUpdateFailure) {
   MockURLRequestThrottlerHeaderAdapter failure_response(503);
-  entry_->UpdateWithResponse("", &failure_response);
+  entry_->UpdateWithResponse(std::string(), &failure_response);
   EXPECT_GT(entry_->GetExponentialBackoffReleaseTime(), entry_->fake_time_now_)
       << "A failure should increase the release_time";
 }
 
 TEST_F(URLRequestThrottlerEntryTest, InterfaceUpdateSuccess) {
   MockURLRequestThrottlerHeaderAdapter success_response(200);
-  entry_->UpdateWithResponse("", &success_response);
+  entry_->UpdateWithResponse(std::string(), &success_response);
   EXPECT_EQ(entry_->GetExponentialBackoffReleaseTime(), entry_->fake_time_now_)
       << "A success should not add any delay";
 }
 
 TEST_F(URLRequestThrottlerEntryTest, InterfaceUpdateSuccessThenFailure) {
   MockURLRequestThrottlerHeaderAdapter failure_response(503);
   MockURLRequestThrottlerHeaderAdapter success_response(200);
-  entry_->UpdateWithResponse("", &success_response);
-  entry_->UpdateWithResponse("", &failure_response);
+  entry_->UpdateWithResponse(std::string(), &success_response);
+  entry_->UpdateWithResponse(std::string(), &failure_response);
   EXPECT_GT(entry_->GetExponentialBackoffReleaseTime(), entry_->fake_time_now_)
       << "This scenario should add delay";
-  entry_->UpdateWithResponse("", &success_response);
+  entry_->UpdateWithResponse(std::string(), &success_response);
 }
 
 TEST_F(URLRequestThrottlerEntryTest, IsEntryReallyOutdated) {
   TimeDelta lifetime = TimeDelta::FromMilliseconds(
       MockURLRequestThrottlerEntry::kDefaultEntryLifetimeMs);
   const TimeDelta kFiveMs = TimeDelta::FromMilliseconds(5);
 
   TimeAndBool test_values[] = {
       TimeAndBool(now_, false, __LINE__),
       TimeAndBool(now_ - kFiveMs, false, __LINE__),
       TimeAndBool(now_ + kFiveMs, false, __LINE__),
       TimeAndBool(now_ - (lifetime - kFiveMs), false, __LINE__),
       TimeAndBool(now_ - lifetime, true, __LINE__),
       TimeAndBool(now_ - (lifetime + kFiveMs), true, __LINE__)};
 
   for (unsigned int i = 0; i < arraysize(test_values); ++i) {
     entry_->set_exponential_backoff_release_time(test_values[i].time);
     EXPECT_EQ(entry_->IsEntryOutdated(), test_values[i].result) <<
         "Test case #" << i << " line " << test_values[i].line << " failed";
   }
 }
 
 TEST_F(URLRequestThrottlerEntryTest, MaxAllowedBackoff) {
   for (int i = 0; i < 30; ++i) {
     MockURLRequestThrottlerHeaderAdapter response_adapter(503);
-    entry_->UpdateWithResponse("", &response_adapter);
+    entry_->UpdateWithResponse(std::string(), &response_adapter);
   }
 
   TimeDelta delay = entry_->GetExponentialBackoffReleaseTime() - now_;
   EXPECT_EQ(delay.InMilliseconds(),
             MockURLRequestThrottlerEntry::kDefaultMaximumBackoffMs);
 }
 
 TEST_F(URLRequestThrottlerEntryTest, MalformedContent) {
   MockURLRequestThrottlerHeaderAdapter response_adapter(503);
   for (int i = 0; i < 5; ++i)
-    entry_->UpdateWithResponse("", &response_adapter);
+    entry_->UpdateWithResponse(std::string(), &response_adapter);
 
   TimeTicks release_after_failures = entry_->GetExponentialBackoffReleaseTime();
 
   // Inform the entry that a response body was malformed, which is supposed to
   // increase the back-off time.  Note that we also submit a successful
   // UpdateWithResponse to pair with ReceivedContentWasMalformed() since that
   // is what happens in practice (if a body is received, then a non-500
   // response must also have been received).
   entry_->ReceivedContentWasMalformed(200);
   MockURLRequestThrottlerHeaderAdapter success_adapter(200);
-  entry_->UpdateWithResponse("", &success_adapter);
+  entry_->UpdateWithResponse(std::string(), &success_adapter);
   EXPECT_GT(entry_->GetExponentialBackoffReleaseTime(), release_after_failures);
 }
 
 TEST_F(URLRequestThrottlerEntryTest, SlidingWindow) {
   int max_send = URLRequestThrottlerEntry::kDefaultMaxSendThreshold;
   int sliding_window =
       URLRequestThrottlerEntry::kDefaultSlidingWindowPeriodMs;
 
   TimeTicks time_1 = entry_->fake_time_now_ +
       TimeDelta::FromMilliseconds(sliding_window / 3);
@@ skipping 108 matching lines @@
 }
 
 void ExpectEntryAllowsAllOnErrorIfOptedOut(
     net::URLRequestThrottlerEntryInterface* entry,
     bool opted_out,
     const URLRequest& request) {
   EXPECT_FALSE(entry->ShouldRejectRequest(request));
   MockURLRequestThrottlerHeaderAdapter failure_adapter(503);
   for (int i = 0; i < 10; ++i) {
     // Host doesn't really matter in this scenario so we skip it.
-    entry->UpdateWithResponse("", &failure_adapter);
+    entry->UpdateWithResponse(std::string(), &failure_adapter);
   }
   EXPECT_NE(opted_out, entry->ShouldRejectRequest(request));
 
   if (opted_out) {
     // We're not mocking out GetTimeNow() in this scenario
     // so add a 100 ms buffer to avoid flakiness (that should always
     // give enough time to get from the TimeTicks::Now() call here
     // to the TimeTicks::Now() call in the entry class).
     EXPECT_GT(TimeTicks::Now() + TimeDelta::FromMilliseconds(100),
               entry->GetExponentialBackoffReleaseTime());
   } else {
     // As above, add 100 ms.
     EXPECT_LT(TimeTicks::Now() + TimeDelta::FromMilliseconds(100),
               entry->GetExponentialBackoffReleaseTime());
   }
 }
 
 TEST_F(URLRequestThrottlerManagerTest, OptOutHeader) {
   MockURLRequestThrottlerManager manager;
   scoped_refptr<net::URLRequestThrottlerEntryInterface> entry =
       manager.RegisterRequestUrl(GURL("http://www.google.com/yodude"));
 
   // Fake a response with the opt-out header.
   MockURLRequestThrottlerHeaderAdapter response_adapter(
-      "",
+      std::string(),
       MockURLRequestThrottlerEntry::kExponentialThrottlingDisableValue,
       200);
   entry->UpdateWithResponse("www.google.com", &response_adapter);
 
   // Ensure that the same entry on error always allows everything.
   ExpectEntryAllowsAllOnErrorIfOptedOut(entry, true, request_);
 
   // Ensure that a freshly created entry (for a different URL on an
   // already opted-out host) also gets "always allow" behavior.
   scoped_refptr<net::URLRequestThrottlerEntryInterface> other_entry =
       manager.RegisterRequestUrl(GURL("http://www.google.com/bingobob"));
   ExpectEntryAllowsAllOnErrorIfOptedOut(other_entry, true, request_);
 
   // Fake a response with the opt-out header incorrectly specified.
   scoped_refptr<net::URLRequestThrottlerEntryInterface> no_opt_out_entry =
       manager.RegisterRequestUrl(GURL("http://www.nike.com/justdoit"));
-  MockURLRequestThrottlerHeaderAdapter wrong_adapter("", "yesplease", 200);
+  MockURLRequestThrottlerHeaderAdapter wrong_adapter(
+      std::string(), "yesplease", 200);
   no_opt_out_entry->UpdateWithResponse("www.nike.com", &wrong_adapter);
   ExpectEntryAllowsAllOnErrorIfOptedOut(no_opt_out_entry, false, request_);
 
   // A localhost entry should always be opted out.
   scoped_refptr<net::URLRequestThrottlerEntryInterface> localhost_entry =
       manager.RegisterRequestUrl(GURL("http://localhost/hello"));
   ExpectEntryAllowsAllOnErrorIfOptedOut(localhost_entry, true, request_);
 }
 
 TEST_F(URLRequestThrottlerManagerTest, ClearOnNetworkChange) {
   for (int i = 0; i < 3; ++i) {
     MockURLRequestThrottlerManager manager;
     scoped_refptr<net::URLRequestThrottlerEntryInterface> entry_before =
         manager.RegisterRequestUrl(GURL("http://www.example.com/"));
     MockURLRequestThrottlerHeaderAdapter failure_adapter(503);
     for (int j = 0; j < 10; ++j) {
       // Host doesn't really matter in this scenario so we skip it.
-      entry_before->UpdateWithResponse("", &failure_adapter);
+      entry_before->UpdateWithResponse(std::string(), &failure_adapter);
     }
     EXPECT_TRUE(entry_before->ShouldRejectRequest(request_));
 
     switch (i) {
       case 0:
         manager.OnIPAddressChanged();
         break;
       case 1:
         manager.OnConnectionTypeChanged(
             net::NetworkChangeNotifier::CONNECTION_UNKNOWN);
         break;
       case 2:
         manager.OnConnectionTypeChanged(
             net::NetworkChangeNotifier::CONNECTION_NONE);
         break;
       default:
         FAIL();
     }
 
     scoped_refptr<net::URLRequestThrottlerEntryInterface> entry_after =
         manager.RegisterRequestUrl(GURL("http://www.example.com/"));
     EXPECT_FALSE(entry_after->ShouldRejectRequest(request_));
   }
 }
 
 }  // namespace net