Remove using namespace in net/quic/quic_stream_sequencer.h

content/browser/loader/resource_scheduler_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/loader/resource_scheduler.h"
 
+#include <string>
+
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/timer/mock_timer.h"
 #include "base/timer/timer.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/browser/loader/resource_message_filter.h"
 #include "content/browser/loader/resource_request_info_impl.h"
@@ skipping 404 matching lines @@
 
   // Throw in one high priority request to make sure that's not a factor.
   scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
   EXPECT_TRUE(high->started());
 
   const int kMaxNumDelayableRequestsPerClient = 10;  // Should match the .cc.
   const int kMaxNumDelayableRequestsPerHost = 6;
   ScopedVector<TestRequest> lows_singlehost;
   // Queue up to the per-host limit (we subtract the current high-pri request).
   for (int i = 0; i < kMaxNumDelayableRequestsPerHost - 1; ++i) {
-    string url = "http://host/low" + base::IntToString(i);
+    std::string url = "http://host/low" + base::IntToString(i);
     lows_singlehost.push_back(NewRequest(url.c_str(), net::LOWEST));
     EXPECT_TRUE(lows_singlehost[i]->started());
   }
 
   scoped_ptr<TestRequest> second_last_singlehost(NewRequest("http://host/last",
                                                             net::LOWEST));
   scoped_ptr<TestRequest> last_singlehost(NewRequest("http://host/s_last",
                                                      net::LOWEST));
 
   EXPECT_FALSE(second_last_singlehost->started());
   high.reset();
   EXPECT_TRUE(second_last_singlehost->started());
   EXPECT_FALSE(last_singlehost->started());
   lows_singlehost.erase(lows_singlehost.begin());
   EXPECT_TRUE(last_singlehost->started());
 
   // Queue more requests from different hosts until we reach the total limit.
   int expected_slots_left =
       kMaxNumDelayableRequestsPerClient - kMaxNumDelayableRequestsPerHost;
   EXPECT_GT(expected_slots_left, 0);
   ScopedVector<TestRequest> lows_differenthosts;
   for (int i = 0; i < expected_slots_left; ++i) {
-    string url = "http://host" + base::IntToString(i) + "/low";
+    std::string url = "http://host" + base::IntToString(i) + "/low";
     lows_differenthosts.push_back(NewRequest(url.c_str(), net::LOWEST));
     EXPECT_TRUE(lows_differenthosts[i]->started());
   }
 
   scoped_ptr<TestRequest> last_differenthost(NewRequest("http://host_new/last",
                                                         net::LOWEST));
   EXPECT_FALSE(last_differenthost->started());
 }
 
 TEST_F(ResourceSchedulerTest, RaisePriorityAndStart) {
@@ skipping 18 matching lines @@
   EXPECT_FALSE(request->started());
   EXPECT_FALSE(idle->started());
 
   ChangeRequestPriority(request.get(), net::LOWEST);
   EXPECT_FALSE(request->started());
   EXPECT_FALSE(idle->started());
 
   const int kMaxNumDelayableRequestsPerClient = 10;  // Should match the .cc.
   ScopedVector<TestRequest> lows;
   for (int i = 0; i < kMaxNumDelayableRequestsPerClient - 1; ++i) {
-    string url = "http://host/low" + base::IntToString(i);
+    std::string url = "http://host/low" + base::IntToString(i);
     lows.push_back(NewRequest(url.c_str(), net::LOWEST));
   }
 
   scheduler_.OnWillInsertBody(kChildId, kRouteId);
   high.reset();
 
   EXPECT_TRUE(request->started());
   EXPECT_FALSE(idle->started());
 }
 
@@ skipping 10 matching lines @@
   ChangeRequestPriority(request.get(), net::IDLE);
   EXPECT_FALSE(request->started());
   EXPECT_FALSE(idle->started());
 
   const int kMaxNumDelayableRequestsPerClient = 10;  // Should match the .cc.
   // 2 fewer filler requests: 1 for the "low" dummy at the start, and 1 for the
   // one at the end, which will be tested.
   const int kNumFillerRequests = kMaxNumDelayableRequestsPerClient - 2;
   ScopedVector<TestRequest> lows;
   for (int i = 0; i < kNumFillerRequests; ++i) {
-    string url = "http://host" + base::IntToString(i) + "/low";
+    std::string url = "http://host" + base::IntToString(i) + "/low";
     lows.push_back(NewRequest(url.c_str(), net::LOWEST));
   }
 
   scheduler_.OnWillInsertBody(kChildId, kRouteId);
   high.reset();
 
   EXPECT_FALSE(request->started());
   EXPECT_TRUE(idle->started());
 }
 
 TEST_F(ResourceSchedulerTest, ReprioritizedRequestGoesToBackOfQueue) {
   // Dummies to enforce scheduling.
   scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
   scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
 
   scoped_ptr<TestRequest> request(NewRequest("http://host/req", net::LOWEST));
   scoped_ptr<TestRequest> idle(NewRequest("http://host/idle", net::IDLE));
   EXPECT_FALSE(request->started());
   EXPECT_FALSE(idle->started());
 
   const int kMaxNumDelayableRequestsPerClient = 10;  // Should match the .cc.
   ScopedVector<TestRequest> lows;
   for (int i = 0; i < kMaxNumDelayableRequestsPerClient; ++i) {
-    string url = "http://host/low" + base::IntToString(i);
+    std::string url = "http://host/low" + base::IntToString(i);
     lows.push_back(NewRequest(url.c_str(), net::LOWEST));
   }
 
   ChangeRequestPriority(request.get(), net::IDLE);
   EXPECT_FALSE(request->started());
   EXPECT_FALSE(idle->started());
 
   ChangeRequestPriority(request.get(), net::LOWEST);
   EXPECT_FALSE(request->started());
   EXPECT_FALSE(idle->started());
 
   scheduler_.OnWillInsertBody(kChildId, kRouteId);
   EXPECT_FALSE(request->started());
   EXPECT_FALSE(idle->started());
 }
 
 TEST_F(ResourceSchedulerTest, HigherIntraPriorityGoesToFrontOfQueue) {
   // Dummies to enforce scheduling.
   scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
   scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
 
   const int kMaxNumDelayableRequestsPerClient = 10;  // Should match the .cc.
   ScopedVector<TestRequest> lows;
   for (int i = 0; i < kMaxNumDelayableRequestsPerClient; ++i) {
-    string url = "http://host/low" + base::IntToString(i);
+    std::string url = "http://host/low" + base::IntToString(i);
     lows.push_back(NewRequest(url.c_str(), net::IDLE));
   }
 
   scoped_ptr<TestRequest> request(NewRequest("http://host/req", net::IDLE));
   EXPECT_FALSE(request->started());
 
   ChangeRequestPriority(request.get(), net::IDLE, 1);
   EXPECT_FALSE(request->started());
 
   scheduler_.OnWillInsertBody(kChildId, kRouteId);
@@ skipping 59 matching lines @@
 
 TEST_F(ResourceSchedulerTest, NewSpdyHostInDelayableRequests) {
   scheduler_.OnWillInsertBody(kChildId, kRouteId);
   const int kMaxNumDelayableRequestsPerClient = 10;  // Should match the .cc.
 
   scoped_ptr<TestRequest> low1_spdy(
       NewRequest("http://spdyhost1:8080/low", net::LOWEST));
   // Cancel a request after we learn the server supports SPDY.
   ScopedVector<TestRequest> lows;
   for (int i = 0; i < kMaxNumDelayableRequestsPerClient - 1; ++i) {
-    string url = "http://host" + base::IntToString(i) + "/low";
+    std::string url = "http://host" + base::IntToString(i) + "/low";
     lows.push_back(NewRequest(url.c_str(), net::LOWEST));
   }
   scoped_ptr<TestRequest> low1(NewRequest("http://host/low", net::LOWEST));
   EXPECT_FALSE(low1->started());
   http_server_properties_.SetSupportsSpdy(
       net::HostPortPair("spdyhost1", 8080), true);
   low1_spdy.reset();
   EXPECT_TRUE(low1->started());
 
   low1.reset();
@@ skipping 1541 matching lines @@
   web_contents_2.reset();
   base::RunLoop().RunUntilIdle();
 
   browser_context.reset();
   render_process_host_factory.reset();
 }
 
 }  // unnamed namespace
 
 }  // namespace content