net: Remove typedef net::URLRequest URLRequest;

chrome/browser/debugger/devtools_http_protocol_handler.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/debugger/devtools_http_protocol_handler.h"
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
 #include "base/string_number_conversions.h"
@@ skipping 90 matching lines @@
     return;
   }
 
   size_t pos = info.path.find("/devtools/");
   if (pos != 0) {
     socket->Send404();
     return;
   }
 
   // Proxy static files from chrome://devtools/*.
-  URLRequest* request = new URLRequest(GURL("chrome:/" + info.path), this);
+  net::URLRequest* request = new net::URLRequest(
+      GURL("chrome:/" + info.path), this);
   Bind(request, socket);
   request->set_context(
       Profile::GetDefaultRequestContext()->GetURLRequestContext());
   request->Start();
 }
 
 void DevToolsHttpProtocolHandler::OnWebSocketRequest(
     HttpListenSocket* socket,
     const HttpServerRequestInfo& request) {
   BrowserThread::PostTask(
@@ skipping 15 matching lines @@
           this,
           &DevToolsHttpProtocolHandler::OnWebSocketMessageUI,
           make_scoped_refptr(socket),
           data));
 }
 
 void DevToolsHttpProtocolHandler::OnClose(HttpListenSocket* socket) {
   SocketToRequestsMap::iterator it = socket_to_requests_io_.find(socket);
   if (it != socket_to_requests_io_.end()) {
     // Dispose delegating socket.
-    for (std::set<URLRequest*>::iterator it2 = it->second.begin();
+    for (std::set<net::URLRequest*>::iterator it2 = it->second.begin();
          it2 != it->second.end(); ++it2) {
-      URLRequest* request = *it2;
+      net::URLRequest* request = *it2;
       request->Cancel();
       request_to_socket_io_.erase(request);
       request_to_buffer_io_.erase(request);
       delete request;
     }
     socket_to_requests_io_.erase(socket);
   }
 
   // This can't use make_scoped_refptr because |socket| is already deleted
   // when this runs -- http://crbug.com/59930
@@ skipping 106 matching lines @@
   SocketToClientHostMap::iterator it = socket_to_client_host_ui_.find(socket);
   if (it == socket_to_client_host_ui_.end())
     return;
   DevToolsClientHostImpl* client_host =
       static_cast<DevToolsClientHostImpl*>(it->second);
   client_host->NotifyCloseListener();
   delete client_host;
   socket_to_client_host_ui_.erase(socket);
 }
 
-void DevToolsHttpProtocolHandler::OnResponseStarted(URLRequest* request) {
+void DevToolsHttpProtocolHandler::OnResponseStarted(net::URLRequest* request) {
   RequestToSocketMap::iterator it = request_to_socket_io_.find(request);
   if (it == request_to_socket_io_.end())
     return;
 
   HttpListenSocket* socket = it->second;
 
   int expected_size = static_cast<int>(request->GetExpectedContentSize());
 
   std::string content_type;
   request->GetMimeType(&content_type);
@@ skipping 13 matching lines @@
   // Some servers may treat HEAD requests as GET requests.  To free up the
   // network connection as soon as possible, signal that the request has
   // completed immediately, without trying to read any data back (all we care
   // about is the response code and headers, which we already have).
   net::IOBuffer* buffer = request_to_buffer_io_[request].get();
   if (request->status().is_success())
     request->Read(buffer, kBufferSize, &bytes_read);
   OnReadCompleted(request, bytes_read);
 }
 
-void DevToolsHttpProtocolHandler::OnReadCompleted(URLRequest* request,
+void DevToolsHttpProtocolHandler::OnReadCompleted(net::URLRequest* request,
                                                   int bytes_read) {
   RequestToSocketMap::iterator it = request_to_socket_io_.find(request);
   if (it == request_to_socket_io_.end())
     return;
 
   HttpListenSocket* socket = it->second;
 
   net::IOBuffer* buffer = request_to_buffer_io_[request].get();
   do {
     if (!request->status().is_success() || bytes_read <= 0)
@@ skipping 13 matching lines @@
 
 void DevToolsHttpProtocolHandler::Init() {
   server_ = HttpListenSocket::Listen("127.0.0.1", port_, this);
 }
 
 // Run on I/O thread
 void DevToolsHttpProtocolHandler::Teardown() {
   server_ = NULL;
 }
 
-void DevToolsHttpProtocolHandler::Bind(URLRequest* request,
+void DevToolsHttpProtocolHandler::Bind(net::URLRequest* request,
                                        HttpListenSocket* socket) {
   request_to_socket_io_[request] = socket;
   SocketToRequestsMap::iterator it = socket_to_requests_io_.find(socket);
   if (it == socket_to_requests_io_.end()) {
-    std::pair<HttpListenSocket*, std::set<URLRequest*> > value(
+    std::pair<HttpListenSocket*, std::set<net::URLRequest*> > value(
         socket,
-        std::set<URLRequest*>());
+        std::set<net::URLRequest*>());
     it = socket_to_requests_io_.insert(value).first;
   }
   it->second.insert(request);
   request_to_buffer_io_[request] = new net::IOBuffer(kBufferSize);
 }
 
-void DevToolsHttpProtocolHandler::RequestCompleted(URLRequest* request) {
+void DevToolsHttpProtocolHandler::RequestCompleted(net::URLRequest* request) {
   RequestToSocketMap::iterator it = request_to_socket_io_.find(request);
   if (it == request_to_socket_io_.end())
     return;
 
   HttpListenSocket* socket = it->second;
   request_to_socket_io_.erase(request);
   SocketToRequestsMap::iterator it2 = socket_to_requests_io_.find(socket);
   it2->second.erase(request);
   request_to_buffer_io_.erase(request);
   delete request;
@@ skipping 42 matching lines @@
     TabStripModel* model = (*it)->tabstrip_model();
     for (int i = 0, size = model->count(); i < size; ++i) {
       NavigationController& controller =
           model->GetTabContentsAt(i)->controller();
       if (controller.session_id().id() == session_id)
         return controller.tab_contents();
     }
   }
   return NULL;
 }