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

net/url_request/url_request.h

 // 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.
 
 #ifndef NET_URL_REQUEST_URL_REQUEST_H_
 #define NET_URL_REQUEST_URL_REQUEST_H_
 #pragma once
 
 #include <map>
 #include <string>
@@ skipping 149 matching lines @@
     virtual void OnReceivedRedirect(URLRequest* request,
                                     const GURL& new_url,
                                     bool* defer_redirect);
 
     // Called when we receive an authentication failure.  The delegate should
     // call request->SetAuth() with the user's credentials once it obtains them,
     // or request->CancelAuth() to cancel the login and display the error page.
     // When it does so, the request will be reissued, restarting the sequence
     // of On* callbacks.
     virtual void OnAuthRequired(URLRequest* request,
-                                net::AuthChallengeInfo* auth_info);
+                                AuthChallengeInfo* auth_info);
 
     // Called when we receive an SSL CertificateRequest message for client
     // authentication.  The delegate should call
     // request->ContinueWithCertificate() with the client certificate the user
     // selected, or request->ContinueWithCertificate(NULL) to continue the SSL
     // handshake without a client certificate.
     virtual void OnCertificateRequested(
         URLRequest* request,
-        net::SSLCertRequestInfo* cert_request_info);
+        SSLCertRequestInfo* cert_request_info);
 
     // Called when using SSL and the server responds with a certificate with
     // an error, for example, whose common name does not match the common name
     // we were expecting for that host.  The delegate should either do the
     // safe thing and Cancel() the request or decide to proceed by calling
-    // ContinueDespiteLastError().  cert_error is a net::ERR_* error code
+    // ContinueDespiteLastError().  cert_error is a ERR_* error code
     // indicating what's wrong with the certificate.
     virtual void OnSSLCertificateError(URLRequest* request,
                                        int cert_error,
-                                       net::X509Certificate* cert);
+                                       X509Certificate* cert);
 
     // Called when reading cookies. |blocked_by_policy| is true if access to
     // cookies was denied due to content settings. This method will never be
     // invoked when LOAD_DO_NOT_SEND_COOKIES is specified.
     virtual void OnGetCookies(URLRequest* request, bool blocked_by_policy);
 
     // Called when a cookie is set. |blocked_by_policy| is true if the cookie
     // was rejected due to content settings. This method will never be invoked
     // when LOAD_DO_NOT_SAVE_COOKIES is specified.
     virtual void OnSetCookie(URLRequest* request,
                              const std::string& cookie_line,
-                             const net::CookieOptions& options,
+                             const CookieOptions& options,
                              bool blocked_by_policy);
 
     // After calling Start(), the delegate will receive an OnResponseStarted
     // callback when the request has completed.  If an error occurred, the
     // request->status() will be set.  On success, all redirects have been
     // followed and the final response is beginning to arrive.  At this point,
     // meta data about the response is available, including for example HTTP
     // response headers if this is a request for a HTTP resource.
     virtual void OnResponseStarted(URLRequest* request) = 0;
 
@@ skipping 120 matching lines @@
   // Appends the given bytes to the request's upload data to be sent
   // immediately via chunked transfer encoding. When all data has been sent,
   // call MarkEndOfChunks() to indicate the end of upload data.
   //
   // This method may be called only after calling EnableChunkedUpload().
   void AppendChunkToUpload(const char* bytes,
                            int bytes_len,
                            bool is_last_chunk);
 
   // Set the upload data directly.
-  void set_upload(net::UploadData* upload);
+  void set_upload(UploadData* upload);
 
   // Get the upload data directly.
-  net::UploadData* get_upload();
+  UploadData* get_upload();
 
   // Returns true if the request has a non-empty message body to upload.
   bool has_upload() const;
 
   // Set an extra request header by ID or name.  These methods may only be
   // called before Start() is called.  It is an error to call it later.
   void SetExtraRequestHeaderById(int header_id, const std::string& value,
                                  bool overwrite);
   void SetExtraRequestHeaderByName(const std::string& name,
                                    const std::string& value, bool overwrite);
 
   // Sets all extra request headers.  Any extra request headers set by other
   // methods are overwritten by this method.  This method may only be called
   // before Start() is called.  It is an error to call it later.
-  void SetExtraRequestHeaders(const net::HttpRequestHeaders& headers);
+  void SetExtraRequestHeaders(const HttpRequestHeaders& headers);
 
-  const net::HttpRequestHeaders& extra_request_headers() const {
+  const HttpRequestHeaders& extra_request_headers() const {
     return extra_request_headers_;
   }
 
   // Returns the current load state for the request.
-  net::LoadState GetLoadState() const;
+  LoadState GetLoadState() const;
 
   // Returns the current upload progress in bytes.
   uint64 GetUploadProgress() const;
 
   // Get response header(s) by ID or name.  These methods may only be called
   // once the delegate's OnResponseStarted method has been called.  Headers
   // that appear more than once in the response are coalesced, with values
   // separated by commas (per RFC 2616). This will not work with cookies since
   // comma can be used in cookie values.
   // TODO(darin): add API to enumerate response headers.
@@ skipping 35 matching lines @@
   bool was_fetched_via_proxy() const {
     return response_info_.was_fetched_via_proxy;
   }
 
   // Returns the host and port that the content was fetched from.  See
   // http_response_info.h for caveats relating to cached content.
   HostPortPair GetSocketAddress() const;
 
   // Get all response headers, as a HttpResponseHeaders object.  See comments
   // in HttpResponseHeaders class as to the format of the data.
-  net::HttpResponseHeaders* response_headers() const;
+  HttpResponseHeaders* response_headers() const;
 
   // Get the SSL connection info.
-  const net::SSLInfo& ssl_info() const {
+  const SSLInfo& ssl_info() const {
     return response_info_.ssl_info;
   }
 
   // Returns the cookie values included in the response, if the request is one
   // that can have cookies.  Returns true if the request is a cookie-bearing
   // type, false otherwise.  This method may only be called once the
   // delegate's OnResponseStarted method has been called.
   bool GetResponseCookies(ResponseCookies* cookies);
 
   // Get the mime type.  This method may only be called once the delegate's
   // OnResponseStarted method has been called.
   void GetMimeType(std::string* mime_type);
 
   // Get the charset (character encoding).  This method may only be called once
   // the delegate's OnResponseStarted method has been called.
   void GetCharset(std::string* charset);
 
   // Returns the HTTP response code (e.g., 200, 404, and so on).  This method
   // may only be called once the delegate's OnResponseStarted method has been
   // called.  For non-HTTP requests, this method returns -1.
   int GetResponseCode();
 
   // Get the HTTP response info in its entirety.
-  const net::HttpResponseInfo& response_info() const { return response_info_; }
+  const HttpResponseInfo& response_info() const { return response_info_; }
 
-  // Access the net::LOAD_* flags modifying this request (see load_flags.h).
+  // Access the LOAD_* flags modifying this request (see load_flags.h).
   int load_flags() const { return load_flags_; }
   void set_load_flags(int flags) { load_flags_ = flags; }
 
   // Returns true if the request is "pending" (i.e., if Start() has been called,
   // and the response has not yet been called).
   bool is_pending() const { return is_pending_; }
 
   // Returns the error status of the request.
-  const net::URLRequestStatus& status() const { return status_; }
+  const URLRequestStatus& status() const { return status_; }
 
   // Returns a globally unique identifier for this request.
   uint64 identifier() const { return identifier_; }
 
   // This method is called to start the request.  The delegate will receive
   // a OnResponseStarted callback when the request is started.
   void Start();
 
   // This method may be called at any time after Start() has been called to
   // cancel the request.  This method may be called many times, and it has
   // no effect once the response has completed.  It is guaranteed that no
   // methods of the delegate will be called after the request has been
   // cancelled, including during the call to Cancel itself.
   void Cancel();
 
   // Cancels the request and sets the error to |os_error| (see net_error_list.h
   // for values).
   void SimulateError(int os_error);
 
   // Cancels the request and sets the error to |os_error| (see net_error_list.h
   // for values) and attaches |ssl_info| as the SSLInfo for that request.  This
   // is useful to attach a certificate and certificate error to a canceled
   // request.
-  void SimulateSSLError(int os_error, const net::SSLInfo& ssl_info);
+  void SimulateSSLError(int os_error, const SSLInfo& ssl_info);
 
   // Read initiates an asynchronous read from the response, and must only
   // be called after the OnResponseStarted callback is received with a
   // successful status.
   // If data is available, Read will return true, and the data and length will
   // be returned immediately.  If data is not available, Read returns false,
   // and an asynchronous Read is initiated.  The Read is finished when
   // the caller receives the OnReadComplete callback.  Unless the request was
   // cancelled, OnReadComplete will always be called, even if the read failed.
   //
   // The buf parameter is a buffer to receive the data.  If the operation
   // completes asynchronously, the implementation will reference the buffer
   // until OnReadComplete is called.  The buffer must be at least max_bytes in
   // length.
   //
   // The max_bytes parameter is the maximum number of bytes to read.
   //
   // The bytes_read parameter is an output parameter containing the
   // the number of bytes read.  A value of 0 indicates that there is no
   // more data available to read from the stream.
   //
   // If a read error occurs, Read returns false and the request->status
   // will be set to an error.
-  bool Read(net::IOBuffer* buf, int max_bytes, int* bytes_read);
+  bool Read(IOBuffer* buf, int max_bytes, int* bytes_read);
 
   // If this request is being cached by the HTTP cache, stop subsequent caching.
   // Note that this method has no effect on other (simultaneous or not) requests
   // for the same resource. The typical example is a request that results in
   // the data being stored to disk (downloaded instead of rendered) so we don't
   // want to store it twice.
   void StopCaching();
 
   // This method may be called to follow a redirect that was deferred in
   // response to an OnReceivedRedirect call.
   void FollowDeferredRedirect();
 
   // One of the following two methods should be called in response to an
   // OnAuthRequired() callback (and only then).
   // SetAuth will reissue the request with the given credentials.
   // CancelAuth will give up and display the error page.
   void SetAuth(const string16& username, const string16& password);
   void CancelAuth();
 
   // This method can be called after the user selects a client certificate to
   // instruct this URLRequest to continue with the request with the
   // certificate.  Pass NULL if the user doesn't have a client certificate.
-  void ContinueWithCertificate(net::X509Certificate* client_cert);
+  void ContinueWithCertificate(X509Certificate* client_cert);
 
   // This method can be called after some error notifications to instruct this
   // URLRequest to ignore the current error and continue with the request.  To
   // cancel the request instead, call Cancel().
   void ContinueDespiteLastError();
 
   // Used to specify the context (cookie store, cache) for this request.
   URLRequestContext* context() const;
   void set_context(URLRequestContext* context);
 
-  const net::BoundNetLog& net_log() const { return net_log_; }
+  const BoundNetLog& net_log() const { return net_log_; }
 
   // Returns the expected content size if available
   int64 GetExpectedContentSize() const;
 
   // Returns the priority level for this request.
-  net::RequestPriority priority() const { return priority_; }
-  void set_priority(net::RequestPriority priority) {
-    DCHECK_GE(priority, net::HIGHEST);
-    DCHECK_LT(priority, net::NUM_PRIORITIES);
+  RequestPriority priority() const { return priority_; }
+  void set_priority(RequestPriority priority) {
+    DCHECK_GE(priority, HIGHEST);
+    DCHECK_LT(priority, NUM_PRIORITIES);
     priority_ = priority;
   }
 
 #ifdef UNIT_TEST
   URLRequestJob* job() { return job_; }
 #endif
 
  protected:
   // Allow the URLRequestJob class to control the is_pending() flag.
   void set_is_pending(bool value) { is_pending_ = value; }
 
   // Allow the URLRequestJob class to set our status too
-  void set_status(const net::URLRequestStatus& value) { status_ = value; }
+  void set_status(const URLRequestStatus& value) { status_ = value; }
 
-  // Allow the URLRequestJob to redirect this request.  Returns net::OK if
+  // Allow the URLRequestJob to redirect this request.  Returns OK if
   // successful, otherwise an error code is returned.
   int Redirect(const GURL& location, int http_status_code);
 
   // Called by URLRequestJob to allow interception when a redirect occurs.
   void ReceivedRedirect(const GURL& location, bool* defer_redirect);
 
   // Called by URLRequestJob to allow interception when the final response
   // occurs.
   void ResponseStarted();
 
@@ skipping 12 matching lines @@
   void RestartWithJob(URLRequestJob* job);
   void PrepareToRestart();
 
   // Detaches the job from this request in preparation for this object going
   // away or the job being replaced. The job will not call us back when it has
   // been orphaned.
   void OrphanJob();
 
   // Cancels the request and set the error and ssl info for this request to the
   // passed values.
-  void DoCancel(int os_error, const net::SSLInfo& ssl_info);
+  void DoCancel(int os_error, const SSLInfo& ssl_info);
 
   // Resumes or blocks a request paused by the NetworkDelegate::OnBeforeRequest
   // handler. If |blocked| is true, the request is blocked and an error page is
   // returned indicating so. This should only be called after Start is called
   // and OnBeforeRequest returns true (signalling that the request should be
   // paused).
   void BeforeRequestComplete(int error);
 
   // Contextual information used for this request (can be NULL). This contains
   // most of the dependencies which are shared between requests (disk cache,
   // cookie store, socket pool, etc.)
   scoped_refptr<URLRequestContext> context_;
 
   // Tracks the time spent in various load states throughout this request.
-  net::BoundNetLog net_log_;
+  BoundNetLog net_log_;
 
   scoped_refptr<URLRequestJob> job_;
-  scoped_refptr<net::UploadData> upload_;
+  scoped_refptr<UploadData> upload_;
   GURL url_;
   GURL original_url_;
   GURL first_party_for_cookies_;
   std::string method_;  // "GET", "POST", etc. Should be all uppercase.
   std::string referrer_;
-  net::HttpRequestHeaders extra_request_headers_;
+  HttpRequestHeaders extra_request_headers_;
   int load_flags_;  // Flags indicating the request type for the load;
                     // expected values are LOAD_* enums above.
 
   Delegate* delegate_;
 
   // Current error status of the job. When no error has been encountered, this
   // will be SUCCESS. If multiple errors have been encountered, this will be
   // the first non-SUCCESS status seen.
-  net::URLRequestStatus status_;
+  URLRequestStatus status_;
 
   // The HTTP response info, lazily initialized.
-  net::HttpResponseInfo response_info_;
+  HttpResponseInfo response_info_;
 
   // Tells us whether the job is outstanding. This is true from the time
   // Start() is called to the time we dispatch RequestComplete and indicates
   // whether the job is active.
   bool is_pending_;
 
   // Externally-defined data accessible by key
   UserDataMap user_data_;
 
   // Number of times we're willing to redirect.  Used to guard against
   // infinite redirects.
   int redirect_limit_;
 
   // Cached value for use after we've orphaned the job handling the
   // first transaction in a request involving redirects.
   uint64 final_upload_progress_;
 
   // The priority level for this request.  Objects like ClientSocketPool use
   // this to determine which URLRequest to allocate sockets to first.
-  net::RequestPriority priority_;
+  RequestPriority priority_;
 
   // A globally unique identifier for this request.
   const uint64 identifier_;
 
   base::debug::LeakTracker<URLRequest> leak_tracker_;
 
   // Callback passed to the network delegate to notify us when a blocked request
   // is ready to be resumed or canceled.
   scoped_refptr< CancelableCompletionCallback<URLRequest> >
       before_request_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(URLRequest);
 };
 
 }  // namespace net
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_H_