net: Remove typedef net::URLRequestStatus URLRequestStatus;

chrome/browser/automation/url_request_automation_job.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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/automation/url_request_automation_job.h"
 
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/time.h"
 #include "chrome/browser/automation/automation_resource_message_filter.h"
 #include "chrome/browser/browser_thread.h"
@@ skipping 130 matching lines @@
     // filter so it can be serviced later when we receive a request from the
     // external host to connect to the corresponding external tab.
     message_filter_->RegisterRequest(this);
   }
 }
 
 void URLRequestAutomationJob::Kill() {
   if (message_filter_.get()) {
     if (!is_pending()) {
       message_filter_->Send(new AutomationMsg_RequestEnd(tab_, id_,
-          URLRequestStatus(URLRequestStatus::CANCELED, net::ERR_ABORTED)));
+          net::URLRequestStatus(net::URLRequestStatus::CANCELED,
+                                net::ERR_ABORTED)));
     }
   }
   DisconnectFromMessageFilter();
   net::URLRequestJob::Kill();
 }
 
 bool URLRequestAutomationJob::ReadRawData(
     net::IOBuffer* buf, int buf_size, int* bytes_read) {
   DVLOG(1) << "URLRequestAutomationJob: " << request_->url().spec()
            << " - read pending: " << buf_size;
 
   // We should not receive a read request for a pending job.
   DCHECK(!is_pending());
 
   pending_buf_ = buf;
   pending_buf_size_ = buf_size;
 
   if (message_filter_) {
     message_filter_->Send(new AutomationMsg_RequestRead(tab_, id_, buf_size));
-    SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
+    SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING, 0));
   } else {
     MessageLoop::current()->PostTask(
         FROM_HERE,
         method_factory_.NewRunnableMethod(
             &URLRequestAutomationJob::NotifyJobCompletionTask));
   }
   return false;
 }
 
 bool URLRequestAutomationJob::GetMimeType(std::string* mime_type) const {
@@ skipping 102 matching lines @@
 }
 
 void URLRequestAutomationJob::OnDataAvailable(
     int id, const std::string& bytes) {
   DVLOG(1) << "URLRequestAutomationJob: " << request_->url().spec()
            << " - data available, Size: " << bytes.size();
   DCHECK(!bytes.empty());
 
   // The request completed, and we have all the data.
   // Clear any IO pending status.
-  SetStatus(URLRequestStatus());
+  SetStatus(net::URLRequestStatus());
 
   if (pending_buf_ && pending_buf_->data()) {
     DCHECK_GE(pending_buf_size_, bytes.size());
     const int bytes_to_copy = std::min(bytes.size(), pending_buf_size_);
     memcpy(pending_buf_->data(), &bytes[0], bytes_to_copy);
 
     pending_buf_ = NULL;
     pending_buf_size_ = 0;
 
     NotifyReadComplete(bytes_to_copy);
   } else {
     NOTREACHED() << "Received unexpected data of length:" << bytes.size();
   }
 }
 
 void URLRequestAutomationJob::OnRequestEnd(
-    int id, const URLRequestStatus& status) {
+    int id, const net::URLRequestStatus& status) {
 #ifndef NDEBUG
   std::string url;
   if (request_)
     url = request_->url().spec();
   DVLOG(1) << "URLRequestAutomationJob: " << url << " - request end. Status: "
            << status.status();
 #endif
 
   // TODO(tommi): When we hit certificate errors, notify the delegate via
   // OnSSLCertificateError().  Right now we don't have the certificate
   // so we don't.  We could possibly call OnSSLCertificateError with a NULL
   // certificate, but I'm not sure if all implementations expect it.
-  // if (status.status() == URLRequestStatus::FAILED &&
+  // if (status.status() == net::URLRequestStatus::FAILED &&
   //    net::IsCertificateError(status.os_error()) && request_->delegate()) {
   //  request_->delegate()->OnSSLCertificateError(request_, status.os_error());
   // }
 
   DisconnectFromMessageFilter();
   // NotifyDone may have been called on the job if the original request was
   // redirected.
   if (!is_done()) {
     // We can complete the job if we have a valid response or a pending read.
     // An end request can be received in the following cases
@@ skipping 38 matching lines @@
 
   // If the job is cancelled before we got a chance to start it
   // we have nothing much to do here.
   if (is_done())
     return;
 
   // We should not receive a Start request for a pending job.
   DCHECK(!is_pending());
 
   if (!request_) {
-    NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED,
-        net::ERR_FAILED));
+    NotifyStartError(net::URLRequestStatus(net::URLRequestStatus::FAILED,
+                                           net::ERR_FAILED));
     return;
   }
 
   // Register this request with automation message filter.
   message_filter_->RegisterRequest(this);
 
   // Strip unwanted headers.
   net::HttpRequestHeaders new_request_headers;
   new_request_headers.MergeFrom(request_->extra_request_headers());
   for (size_t i = 0; i < arraysize(kFilteredHeaderStrings); ++i)
@@ skipping 71 matching lines @@
   if (!is_done()) {
     NotifyDone(request_status_);
   }
   // Reset any pending reads.
   if (pending_buf_) {
     pending_buf_ = NULL;
     pending_buf_size_ = 0;
     NotifyReadComplete(0);
   }
 }