net: Remove typedef net::URLRequest URLRequest;

net/url_request/url_request_job.h

 // 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.
 
 #ifndef NET_URL_REQUEST_URL_REQUEST_JOB_H_
 #define NET_URL_REQUEST_URL_REQUEST_JOB_H_
 #pragma once
 
 #include <string>
 #include <vector>
@@ skipping 47 matching lines @@
   virtual void SetExtraRequestHeaders(const net::HttpRequestHeaders& headers);
 
   // If any error occurs while starting the Job, NotifyStartError should be
   // called.
   // This helps ensure that all errors follow more similar notification code
   // paths, which should simplify testing.
   virtual void Start() = 0;
 
   // This function MUST somehow call NotifyDone/NotifyCanceled or some requests
   // will get leaked. Certain callers use that message to know when they can
-  // delete their URLRequest object, even when doing a cancel. The default Kill
-  // implementation calls NotifyCanceled, so it is recommended that subclasses
-  // call URLRequestJob::Kill() after doing any additional work.
+  // delete their net::URLRequest object, even when doing a cancel. The default
+  // Kill implementation calls NotifyCanceled, so it is recommended that
+  // subclasses call URLRequestJob::Kill() after doing any additional work.
   //
   // The job should endeavor to stop working as soon as is convenient, but must
   // not send and complete notifications from inside this function. Instead,
   // complete notifications (including "canceled") should be sent from a
   // callback run from the message loop.
   //
   // The job is not obliged to immediately stop sending data in response to
   // this call, nor is it obliged to fail with "canceled" unless not all data
   // was sent as a result. A typical case would be where the job is almost
   // complete and can succeed before the canceled notification can be
   // dispatched (from the message loop).
   //
   // The job should be prepared to receive multiple calls to kill it, but only
   // one notification must be issued.
   virtual void Kill();
 
   // Called to detach the request from this Job.  Results in the Job being
   // killed off eventually. The job must not use the request pointer any more.
   void DetachRequest();
 
   // Called to read post-filtered data from this Job, returning the number of
   // bytes read, 0 when there is no more data, or -1 if there was an error.
-  // This is just the backend for URLRequest::Read, see that function for more
-  // info.
+  // This is just the backend for net::URLRequest::Read, see that function for
+  // more info.
   bool Read(net::IOBuffer* buf, int buf_size, int* bytes_read);
 
   // Stops further caching of this request, if any. For more info, see
-  // URLRequest::StopCaching().
+  // net::URLRequest::StopCaching().
   virtual void StopCaching();
 
   // Called to fetch the current load state for the job.
   virtual net::LoadState GetLoadState() const;
 
   // Called to get the upload progress in bytes.
   virtual uint64 GetUploadProgress() const;
 
   // Called to fetch the charset for this request.  Only makes sense for some
   // types of requests. Returns true on success.  Calling this on a type that
@@ skipping 41 matching lines @@
   //
   // The caller is responsible for following the redirect by setting up an
   // appropriate replacement Job. Note that the redirected location may be
   // invalid, the caller should be sure it can handle this.
   //
   // The default implementation inspects the response_info_.
   virtual bool IsRedirectResponse(GURL* location, int* http_status_code);
 
   // Called to determine if it is okay to redirect this job to the specified
   // location.  This may be used to implement protocol-specific restrictions.
-  // If this function returns false, then the URLRequest will fail reporting
-  // net::ERR_UNSAFE_REDIRECT.
+  // If this function returns false, then the net::URLRequest will fail
+  // reporting net::ERR_UNSAFE_REDIRECT.
   virtual bool IsSafeRedirect(const GURL& location);
 
   // Called to determine if this response is asking for authentication.  Only
   // makes sense for some types of requests.  The caller is responsible for
   // obtaining the credentials passing them to SetAuth.
   virtual bool NeedsAuth();
 
   // Fills the authentication info with the server's response.
   virtual void GetAuthChallengeInfo(
       scoped_refptr<net::AuthChallengeInfo>* auth_info);
@@ skipping 61 matching lines @@
   // a glorified set_status, but also does internal state checking and
   // job tracking.  It should be called once per request, when the job is
   // finished doing all IO.
   void NotifyDone(const URLRequestStatus& status);
 
   // Some work performed by NotifyDone must be completed on a separate task
   // so as to avoid re-entering the delegate.  This method exists to perform
   // that work.
   void CompleteNotifyDone();
 
-  // Used as an asynchronous callback for Kill to notify the URLRequest that
-  // we were canceled.
+  // Used as an asynchronous callback for Kill to notify the net::URLRequest
+  // that we were canceled.
   void NotifyCanceled();
 
   // Notifies the job the request should be restarted.
   // Should only be called if the job has not started a resposne.
   void NotifyRestartRequired();
 
   // Called to read raw (pre-filtered) data from this Job.
   // If returning true, data was read from the job.  buf will contain
   // the data, and bytes_read will receive the number of bytes read.
   // If returning true, and bytes_read is returned as 0, there is no
   // additional data to be read.
   // If returning false, an error occurred or an async IO is now pending.
   // If async IO is pending, the status of the request will be
   // URLRequestStatus::IO_PENDING, and buf must remain available until the
-  // operation is completed.  See comments on URLRequest::Read for more info.
+  // operation is completed.  See comments on net::URLRequest::Read for more
+  // info.
   virtual bool ReadRawData(net::IOBuffer* buf, int buf_size, int *bytes_read);
 
   // Informs the filter that data has been read into its buffer
   void FilteredDataRead(int bytes_read);
 
   // Reads filtered data from the request.  Returns true if successful,
   // false otherwise.  Note, if there is not enough data received to
   // return data, this call can issue a new async IO request under
   // the hood.
   bool ReadFilteredData(int *bytes_read);
@@ skipping 21 matching lines @@
   // Whether the job is doing performance profiling
   bool is_profiling_;
 
   // Contains IO performance measurement when profiling is enabled.
   scoped_ptr<URLRequestJobMetrics> metrics_;
 
   // The number of bytes read before passing to the filter.
   int prefilter_bytes_read_;
   // The number of bytes read after passing through the filter.
   int postfilter_bytes_read_;
-  // True when (we believe) the content in this URLRequest was compressible.
+  // True when (we believe) the content in this net::URLRequest was
+  // compressible.
   bool is_compressible_content_;
-  // True when the content in this URLRequest was compressed.
+  // True when the content in this net::URLRequest was compressed.
   bool is_compressed_;
 
  private:
   // Size of filter input buffers used by this class.
   static const int kFilterBufSize;
 
   // When data filtering is enabled, this function is used to read data
   // for the filter.  Returns true if raw data was read.  Returns false if
   // an error occurred (or we are waiting for IO to complete).
   bool ReadRawDataForFilter(int *bytes_read);
@@ skipping 106 matching lines @@
   int observed_packet_count_;
 
   DISALLOW_COPY_AND_ASSIGN(URLRequestJob);
 };
 
 }  // namespace net
 
 typedef net::URLRequestJob URLRequestJob;
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_JOB_H_