net: Remove prefix net:: from some places that already are in namespace net.

net/proxy/proxy_script_fetcher_impl.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/proxy/proxy_script_fetcher_impl.h"
 
 #include "base/compiler_specific.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 52 matching lines @@
   // outside of |charset| (i.e. invalid), then substitute them with
   // U+FFFD rather than failing.
   base::CodepageToUTF16(bytes, codepage,
                         base::OnStringConversionError::SUBSTITUTE,
                         utf16);
 }
 
 }  // namespace
 
 ProxyScriptFetcherImpl::ProxyScriptFetcherImpl(
-    net::URLRequestContext* url_request_context)
+    URLRequestContext* url_request_context)
     : ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)),
       url_request_context_(url_request_context),
-      buf_(new net::IOBuffer(kBufSize)),
+      buf_(new IOBuffer(kBufSize)),
       next_id_(0),
       cur_request_(NULL),
       cur_request_id_(0),
       callback_(NULL),
       result_code_(OK),
       result_text_(NULL),
       max_response_bytes_(kDefaultMaxResponseBytes),
       max_duration_(base::TimeDelta::FromMilliseconds(kDefaultMaxDurationMs)) {
   DCHECK(url_request_context);
 }
 
 ProxyScriptFetcherImpl::~ProxyScriptFetcherImpl() {
-  // The net::URLRequest's destructor will cancel the outstanding request, and
+  // The URLRequest's destructor will cancel the outstanding request, and
   // ensure that the delegate (this) is not called again.
 }
 
 int ProxyScriptFetcherImpl::Fetch(const GURL& url,
                                   string16* text,
                                   CompletionCallback* callback) {
   // It is invalid to call Fetch() while a request is already in progress.
   DCHECK(!cur_request_.get());
 
   DCHECK(callback);
   DCHECK(text);
 
-  cur_request_.reset(new net::URLRequest(url, this));
+  cur_request_.reset(new URLRequest(url, this));
   cur_request_->set_context(url_request_context_);
   cur_request_->set_method("GET");
 
   // Make sure that the PAC script is downloaded using a direct connection,
   // to avoid circular dependencies (fetching is a part of proxy resolution).
   // Also disable the use of the disk cache. The cache is disabled so that if
   // the user switches networks we don't potentially use the cached response
   // from old network when we should in fact be re-fetching on the new network.
   cur_request_->set_load_flags(LOAD_BYPASS_PROXY | LOAD_DISABLE_CACHE);
 
   // Save the caller's info for notification on completion.
   callback_ = callback;
   result_text_ = text;
 
   bytes_read_so_far_.clear();
 
   // Post a task to timeout this request if it takes too long.
   cur_request_id_ = ++next_id_;
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
       task_factory_.NewRunnableMethod(&ProxyScriptFetcherImpl::OnTimeout,
                                       cur_request_id_),
       static_cast<int>(max_duration_.InMilliseconds()));
 
   // Start the request.
   cur_request_->Start();
   return ERR_IO_PENDING;
 }
 
 void ProxyScriptFetcherImpl::Cancel() {
-  // ResetCurRequestState will free the net::URLRequest, which will cause
+  // ResetCurRequestState will free the URLRequest, which will cause
   // cancellation.
   ResetCurRequestState();
 }
 
-net::URLRequestContext* ProxyScriptFetcherImpl::GetRequestContext() {
+URLRequestContext* ProxyScriptFetcherImpl::GetRequestContext() {
   return url_request_context_;
 }
 
-void ProxyScriptFetcherImpl::OnAuthRequired(net::URLRequest* request,
+void ProxyScriptFetcherImpl::OnAuthRequired(URLRequest* request,
                                             AuthChallengeInfo* auth_info) {
   DCHECK_EQ(request, cur_request_.get());
   // TODO(eroman):
   LOG(WARNING) << "Auth required to fetch PAC script, aborting.";
   result_code_ = ERR_NOT_IMPLEMENTED;
   request->CancelAuth();
 }
 
-void ProxyScriptFetcherImpl::OnSSLCertificateError(net::URLRequest* request,
+void ProxyScriptFetcherImpl::OnSSLCertificateError(URLRequest* request,
                                                    int cert_error,
                                                    X509Certificate* cert) {
   DCHECK_EQ(request, cur_request_.get());
   LOG(WARNING) << "SSL certificate error when fetching PAC script, aborting.";
   // Certificate errors are in same space as net errors.
   result_code_ = cert_error;
   request->Cancel();
 }
 
-void ProxyScriptFetcherImpl::OnResponseStarted(net::URLRequest* request) {
+void ProxyScriptFetcherImpl::OnResponseStarted(URLRequest* request) {
   DCHECK_EQ(request, cur_request_.get());
 
   if (!request->status().is_success()) {
     OnResponseCompleted(request);
     return;
   }
 
   // Require HTTP responses to have a success status code.
   if (request->url().SchemeIs("http") || request->url().SchemeIs("https")) {
     // NOTE about status codes: We are like Firefox 3 in this respect.
@@ skipping 13 matching lines @@
     cur_request_->GetMimeType(&mime_type);
     if (!IsPacMimeType(mime_type)) {
       VLOG(1) << "Fetched PAC script does not have a proper mime type: "
               << mime_type;
     }
   }
 
   ReadBody(request);
 }
 
-void ProxyScriptFetcherImpl::OnReadCompleted(net::URLRequest* request,
+void ProxyScriptFetcherImpl::OnReadCompleted(URLRequest* request,
                                              int num_bytes) {
   DCHECK_EQ(request, cur_request_.get());
   if (ConsumeBytesRead(request, num_bytes)) {
     // Keep reading.
     ReadBody(request);
   }
 }
 
-void ProxyScriptFetcherImpl::OnResponseCompleted(net::URLRequest* request) {
+void ProxyScriptFetcherImpl::OnResponseCompleted(URLRequest* request) {
   DCHECK_EQ(request, cur_request_.get());
 
   // Use |result_code_| as the request's error if we have already set it to
   // something specific.
   if (result_code_ == OK && !request->status().is_success())
     result_code_ = request->status().os_error();
 
   FetchCompleted();
 }
 
-void ProxyScriptFetcherImpl::ReadBody(net::URLRequest* request) {
+void ProxyScriptFetcherImpl::ReadBody(URLRequest* request) {
   // Read as many bytes as are available synchronously.
   while (true) {
     int num_bytes;
     if (!request->Read(buf_, kBufSize, &num_bytes)) {
       // Check whether the read failed synchronously.
       if (!request->status().is_io_pending())
         OnResponseCompleted(request);
       return;
     }
     if (!ConsumeBytesRead(request, num_bytes))
       return;
   }
 }
 
-bool ProxyScriptFetcherImpl::ConsumeBytesRead(net::URLRequest* request,
+bool ProxyScriptFetcherImpl::ConsumeBytesRead(URLRequest* request,
                                               int num_bytes) {
   if (num_bytes <= 0) {
     // Error while reading, or EOF.
     OnResponseCompleted(request);
     return false;
   }
 
   // Enforce maximum size bound.
   if (num_bytes + bytes_read_so_far_.size() >
       static_cast<size_t>(max_response_bytes_)) {
@@ skipping 13 matching lines @@
     cur_request_->GetCharset(&charset);
     ConvertResponseToUTF16(charset, bytes_read_so_far_, result_text_);
   } else {
     // On error, the caller expects empty string for bytes.
     result_text_->clear();
   }
 
   int result_code = result_code_;
   CompletionCallback* callback = callback_;
 
-  // Hold a reference to the net::URLRequestContext to prevent re-entrancy from
-  // ~net::URLRequestContext.
-  scoped_refptr<net::URLRequestContext> context(cur_request_->context());
+  // Hold a reference to the URLRequestContext to prevent re-entrancy from
+  // ~URLRequestContext.
+  scoped_refptr<URLRequestContext> context(cur_request_->context());
   ResetCurRequestState();
 
   callback->Run(result_code);
 }
 
 void ProxyScriptFetcherImpl::ResetCurRequestState() {
   cur_request_.reset();
   cur_request_id_ = 0;
   callback_ = NULL;
   result_code_ = OK;
   result_text_ = NULL;
 }
 
 void ProxyScriptFetcherImpl::OnTimeout(int id) {
-  // Timeout tasks may outlive the net::URLRequest they reference. Make sure it
+  // Timeout tasks may outlive the URLRequest they reference. Make sure it
   // is still applicable.
   if (cur_request_id_ != id)
     return;
 
   DCHECK(cur_request_.get());
   result_code_ = ERR_TIMED_OUT;
   cur_request_->Cancel();
 }
 
 base::TimeDelta ProxyScriptFetcherImpl::SetTimeoutConstraint(
     base::TimeDelta timeout) {
   base::TimeDelta prev = max_duration_;
   max_duration_ = timeout;
   return prev;
 }
 
 size_t ProxyScriptFetcherImpl::SetSizeConstraint(size_t size_bytes) {
   size_t prev = max_response_bytes_;
   max_response_bytes_ = size_bytes;
   return prev;
 }
 
 }  // namespace net