net: Remove typedef net::URLRequest URLRequest;

chrome/browser/net/connection_tester.cc

 // Copyright (c) 2010 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 "chrome/browser/net/connection_tester.h"
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 205 matching lines @@
 
   IOThread* io_thread_;
 };
 
 }  // namespace
 
 // ConnectionTester::TestRunner ----------------------------------------------
 
 // TestRunner is a helper class for running an individual experiment. It can
 // be deleted any time after it is started, and this will abort the request.
-class ConnectionTester::TestRunner : public URLRequest::Delegate {
+class ConnectionTester::TestRunner : public net::URLRequest::Delegate {
  public:
   // |tester| must remain alive throughout the TestRunner's lifetime.
   // |tester| will be notified of completion.
   explicit TestRunner(ConnectionTester* tester) : tester_(tester) {}
 
   // Starts running |experiment|. Notifies tester->OnExperimentCompleted() when
   // it is done.
   void Run(const Experiment& experiment);
 
-  // URLRequest::Delegate implementation.
-  virtual void OnResponseStarted(URLRequest* request);
-  virtual void OnReadCompleted(URLRequest* request, int bytes_read);
+  // Overridden from net::URLRequest::Delegate:
+  virtual void OnResponseStarted(net::URLRequest* request);
+  virtual void OnReadCompleted(net::URLRequest* request, int bytes_read);
   // TODO(eroman): handle cases requiring authentication.
 
  private:
   // The number of bytes to read each response body chunk.
   static const int kReadBufferSize = 1024;
 
   // Starts reading the response's body (and keeps reading until an error or
   // end of stream).
-  void ReadBody(URLRequest* request);
+  void ReadBody(net::URLRequest* request);
 
   // Called when the request has completed (for both success and failure).
-  void OnResponseCompleted(URLRequest* request);
+  void OnResponseCompleted(net::URLRequest* request);
 
   ConnectionTester* tester_;
-  scoped_ptr<URLRequest> request_;
+  scoped_ptr<net::URLRequest> request_;
 
   DISALLOW_COPY_AND_ASSIGN(TestRunner);
 };
 
-void ConnectionTester::TestRunner::OnResponseStarted(URLRequest* request) {
+void ConnectionTester::TestRunner::OnResponseStarted(net::URLRequest* request) {
   if (!request->status().is_success()) {
     OnResponseCompleted(request);
     return;
   }
 
   // Start reading the body.
   ReadBody(request);
 }
 
-void ConnectionTester::TestRunner::OnReadCompleted(URLRequest* request,
+void ConnectionTester::TestRunner::OnReadCompleted(net::URLRequest* request,
                                                    int bytes_read) {
   if (bytes_read <= 0) {
     OnResponseCompleted(request);
     return;
   }
 
   // Keep reading until the stream is closed. Throw the data read away.
   ReadBody(request);
 }
 
-void ConnectionTester::TestRunner::ReadBody(URLRequest* request) {
+void ConnectionTester::TestRunner::ReadBody(net::URLRequest* request) {
   // Read the response body |kReadBufferSize| bytes at a time.
   scoped_refptr<net::IOBuffer> unused_buffer(
       new net::IOBuffer(kReadBufferSize));
   int num_bytes;
   if (request->Read(unused_buffer, kReadBufferSize, &num_bytes)) {
     OnReadCompleted(request, num_bytes);
   } else if (!request->status().is_io_pending()) {
     // Read failed synchronously.
     OnResponseCompleted(request);
   }
 }
 
-void ConnectionTester::TestRunner::OnResponseCompleted(URLRequest* request) {
+void ConnectionTester::TestRunner::OnResponseCompleted(
+    net::URLRequest* request) {
   int result = net::OK;
   if (!request->status().is_success()) {
     DCHECK_NE(net::ERR_IO_PENDING, request->status().os_error());
     result = request->status().os_error();
   }
   tester_->OnExperimentCompleted(result);
 }
 
 void ConnectionTester::TestRunner::Run(const Experiment& experiment) {
   // Try to create a URLRequestContext for this experiment.
   scoped_refptr<ExperimentURLRequestContext> context(
       new ExperimentURLRequestContext(tester_->io_thread_));
   int rv = context->Init(experiment);
   if (rv != net::OK) {
     // Complete the experiment with a failure.
     tester_->OnExperimentCompleted(rv);
     return;
   }
 
   // Fetch a request using the experimental context.
-  request_.reset(new URLRequest(experiment.url, this));
+  request_.reset(new net::URLRequest(experiment.url, this));
   request_->set_context(context);
   request_->Start();
 }
 
 // ConnectionTester ----------------------------------------------------------
 
 ConnectionTester::ConnectionTester(Delegate* delegate, IOThread* io_thread)
     : delegate_(delegate), io_thread_(io_thread) {
   DCHECK(delegate);
   DCHECK(io_thread);
@@ skipping 87 matching lines @@
 
   // Notify the delegate of completion.
   delegate_->OnCompletedConnectionTestExperiment(current, result);
 
   if (remaining_experiments_.empty()) {
     delegate_->OnCompletedConnectionTestSuite();
   } else {
     StartNextExperiment();
   }
 }