Remove all "net::" prefixes under net/url_request for code that's

net/url_request/url_request_job.cc

 // 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 "net/url_request/url_request_job.h"
 
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
@@ skipping 18 matching lines @@
       filter_input_byte_count_(0),
       filter_needs_more_output_space_(false),
       filtered_read_buffer_len_(0),
       has_handled_response_(false),
       expected_content_size_(-1),
       deferred_redirect_status_code_(-1),
       ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {
   g_url_request_job_tracker.AddNewJob(this);
 }
 
-void URLRequestJob::SetUpload(net::UploadData* upload) {
+void URLRequestJob::SetUpload(UploadData* upload) {
 }
 
 void URLRequestJob::SetExtraRequestHeaders(
-    const net::HttpRequestHeaders& headers) {
+    const HttpRequestHeaders& headers) {
 }
 
 void URLRequestJob::Kill() {
   // Make sure the request is notified that we are done.  We assume that the
   // request took care of setting its error status before calling Kill.
   if (request_)
     NotifyCanceled();
 }
 
 void URLRequestJob::DetachRequest() {
   request_ = NULL;
 }
 
 // This function calls ReadData to get stream data. If a filter exists, passes
 // the data to the attached filter. Then returns the output from filter back to
 // the caller.
-bool URLRequestJob::Read(net::IOBuffer* buf, int buf_size, int *bytes_read) {
+bool URLRequestJob::Read(IOBuffer* buf, int buf_size, int *bytes_read) {
   bool rv = false;
 
   DCHECK_LT(buf_size, 1000000);  // sanity check
   DCHECK(buf);
   DCHECK(bytes_read);
   DCHECK(filtered_read_buffer_ == NULL);
   DCHECK_EQ(0, filtered_read_buffer_len_);
 
   *bytes_read = 0;
 
@@ skipping 14 matching lines @@
   }
   if (rv && *bytes_read == 0)
     NotifyDone(URLRequestStatus());
   return rv;
 }
 
 void URLRequestJob::StopCaching() {
   // Nothing to do here.
 }
 
-net::LoadState URLRequestJob::GetLoadState() const {
-  return net::LOAD_STATE_IDLE;
+LoadState URLRequestJob::GetLoadState() const {
+  return LOAD_STATE_IDLE;
 }
 
 uint64 URLRequestJob::GetUploadProgress() const {
   return 0;
 }
 
 bool URLRequestJob::GetCharset(std::string* charset) {
   return false;
 }
 
-void URLRequestJob::GetResponseInfo(net::HttpResponseInfo* info) {
+void URLRequestJob::GetResponseInfo(HttpResponseInfo* info) {
 }
 
 bool URLRequestJob::GetResponseCookies(std::vector<std::string>* cookies) {
   return false;
 }
 
 Filter* URLRequestJob::SetupFilter() const {
   return NULL;
 }
 
 bool URLRequestJob::IsRedirectResponse(GURL* location,
                                        int* http_status_code) {
   // For non-HTTP jobs, headers will be null.
-  net::HttpResponseHeaders* headers = request_->response_headers();
+  HttpResponseHeaders* headers = request_->response_headers();
   if (!headers)
     return false;
 
   std::string value;
   if (!headers->IsRedirect(&value))
     return false;
 
   *location = request_->url().Resolve(value);
   *http_status_code = headers->response_code();
   return true;
 }
 
 bool URLRequestJob::IsSafeRedirect(const GURL& location) {
   return true;
 }
 
 bool URLRequestJob::NeedsAuth() {
   return false;
 }
 
 void URLRequestJob::GetAuthChallengeInfo(
-    scoped_refptr<net::AuthChallengeInfo>* auth_info) {
+    scoped_refptr<AuthChallengeInfo>* auth_info) {
   // This will only be called if NeedsAuth() returns true, in which
   // case the derived class should implement this!
   NOTREACHED();
 }
 
 void URLRequestJob::SetAuth(const string16& username,
                             const string16& password) {
   // This will only be called if NeedsAuth() returns true, in which
   // case the derived class should implement this!
   NOTREACHED();
 }
 
 void URLRequestJob::CancelAuth() {
   // This will only be called if NeedsAuth() returns true, in which
   // case the derived class should implement this!
   NOTREACHED();
 }
 
 void URLRequestJob::ContinueWithCertificate(
-    net::X509Certificate* client_cert) {
+    X509Certificate* client_cert) {
   // The derived class should implement this!
   NOTREACHED();
 }
 
 void URLRequestJob::ContinueDespiteLastError() {
   // Implementations should know how to recover from errors they generate.
   // If this code was reached, we are trying to recover from an error that
   // we don't know how to recover from.
   NOTREACHED();
 }
@@ skipping 37 matching lines @@
   if (!request_ || !request_->delegate())
     return;  // The request was destroyed, so there is no more work to do.
 
   if (has_handled_response_)
     return;
 
   DCHECK(!request_->status().is_io_pending());
 
   // Initialize to the current time, and let the subclass optionally override
   // the time stamps if it has that information.  The default request_time is
-  // set by net::URLRequest before it calls our Start method.
+  // set by URLRequest before it calls our Start method.
   request_->response_info_.response_time = base::Time::Now();
   GetResponseInfo(&request_->response_info_);
 
   // When notifying the delegate, the delegate can release the request
   // (and thus release 'this').  After calling to the delgate, we must
   // check the request pointer to see if it still exists, and return
   // immediately if it has been destroyed.  self_preservation ensures our
   // survival until we can get out of this method.
   scoped_refptr<URLRequestJob> self_preservation(this);
 
@@ skipping 24 matching lines @@
     if (request_->status().is_success()) {
       if (defer_redirect) {
         deferred_redirect_url_ = new_location;
         deferred_redirect_status_code_ = http_status_code;
       } else {
         FollowRedirect(new_location, http_status_code);
       }
       return;
     }
   } else if (NeedsAuth()) {
-    scoped_refptr<net::AuthChallengeInfo> auth_info;
+    scoped_refptr<AuthChallengeInfo> auth_info;
     GetAuthChallengeInfo(&auth_info);
     // Need to check for a NULL auth_info because the server may have failed
     // to send a challenge with the 401 response.
     if (auth_info) {
       request_->delegate()->OnAuthRequired(request_, auth_info);
       // Wait for SetAuth or CancelAuth to be called.
       return;
     }
   }
 
@@ skipping 118 matching lines @@
     } else {
       has_handled_response_ = true;
       request_->ResponseStarted();
     }
   }
 }
 
 void URLRequestJob::NotifyCanceled() {
   if (!done_) {
     NotifyDone(URLRequestStatus(URLRequestStatus::CANCELED,
-                                net::ERR_ABORTED));
+                                ERR_ABORTED));
   }
 }
 
 void URLRequestJob::NotifyRestartRequired() {
   DCHECK(!has_handled_response_);
   if (GetStatus().status() != URLRequestStatus::CANCELED)
     request_->Restart();
 }
 
-bool URLRequestJob::ReadRawData(net::IOBuffer* buf, int buf_size,
+bool URLRequestJob::ReadRawData(IOBuffer* buf, int buf_size,
                                 int *bytes_read) {
   DCHECK(bytes_read);
   *bytes_read = 0;
   NotifyDone(URLRequestStatus());
   return false;
 }
 
 void URLRequestJob::FilteredDataRead(int bytes_read) {
   DCHECK(filter_.get());  // don't add data if there is no filter
   filter_->FlushStreamBuffer(bytes_read);
@@ skipping 73 matching lines @@
       case Filter::FILTER_OK: {
         filter_needs_more_output_space_ =
             (filtered_data_len == output_buffer_size);
         *bytes_read = filtered_data_len;
         rv = true;
         break;
       }
       case Filter::FILTER_ERROR: {
         filter_needs_more_output_space_ = false;
         NotifyDone(URLRequestStatus(URLRequestStatus::FAILED,
-                   net::ERR_CONTENT_DECODING_FAILED));
+                   ERR_CONTENT_DECODING_FAILED));
         rv = false;
         break;
       }
       default: {
         NOTREACHED();
         filter_needs_more_output_space_ = false;
         rv = false;
         break;
       }
     }
   } else {
     // we are done, or there is no data left.
     rv = true;
   }
 
   if (rv) {
     // When we successfully finished a read, we no longer need to
     // save the caller's buffers. Release our reference.
     filtered_read_buffer_ = NULL;
     filtered_read_buffer_len_ = 0;
   }
   return rv;
 }
 
 const URLRequestStatus URLRequestJob::GetStatus() {
   if (request_)
     return request_->status();
   // If the request is gone, we must be cancelled.
   return URLRequestStatus(URLRequestStatus::CANCELED,
-                          net::ERR_ABORTED);
+                          ERR_ABORTED);
 }
 
 void URLRequestJob::SetStatus(const URLRequestStatus &status) {
   if (request_)
     request_->set_status(status);
 }
 
 bool URLRequestJob::ReadRawDataForFilter(int* bytes_read) {
   bool rv = false;
 
   DCHECK(bytes_read);
   DCHECK(filter_.get());
 
   *bytes_read = 0;
 
   // Get more pre-filtered data if needed.
   // TODO(mbelshe): is it possible that the filter needs *MORE* data
   //    when there is some data already in the buffer?
   if (!filter_->stream_data_len() && !is_done()) {
-    net::IOBuffer* stream_buffer = filter_->stream_buffer();
+    IOBuffer* stream_buffer = filter_->stream_buffer();
     int stream_buffer_size = filter_->stream_buffer_size();
     rv = ReadRawDataHelper(stream_buffer, stream_buffer_size, bytes_read);
   }
   return rv;
 }
 
-bool URLRequestJob::ReadRawDataHelper(net::IOBuffer* buf, int buf_size,
+bool URLRequestJob::ReadRawDataHelper(IOBuffer* buf, int buf_size,
                                       int* bytes_read) {
   DCHECK(!request_->status().is_io_pending());
   DCHECK(raw_read_buffer_ == NULL);
 
   // Keep a pointer to the read buffer, so we have access to it in the
   // OnRawReadComplete() callback in the event that the read completes
   // asynchronously.
   raw_read_buffer_ = buf;
   bool rv = ReadRawData(buf, buf_size, bytes_read);
 
   if (!request_->status().is_io_pending()) {
     // If the read completes synchronously, either success or failure,
     // invoke the OnRawReadComplete callback so we can account for the
     // completed read.
     OnRawReadComplete(*bytes_read);
   }
   return rv;
 }
 
 void URLRequestJob::FollowRedirect(const GURL& location, int http_status_code) {
   g_url_request_job_tracker.OnJobRedirect(this, location, http_status_code);
 
   int rv = request_->Redirect(location, http_status_code);
-  if (rv != net::OK)
+  if (rv != OK)
     NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, rv));
 }
 
 void URLRequestJob::OnRawReadComplete(int bytes_read) {
   DCHECK(raw_read_buffer_);
   if (bytes_read > 0) {
     RecordBytesRead(bytes_read);
   }
   raw_read_buffer_ = NULL;
 }
 
 void URLRequestJob::RecordBytesRead(int bytes_read) {
   filter_input_byte_count_ += bytes_read;
   UpdatePacketReadTimes();  // Facilitate stats recording if it is active.
   g_url_request_job_tracker.OnBytesRead(this, raw_read_buffer_->data(),
                                         bytes_read);
 }
 
 bool URLRequestJob::FilterHasData() {
     return filter_.get() && filter_->stream_data_len();
 }
 
 void URLRequestJob::UpdatePacketReadTimes() {
 }
 
 }  // namespace net