net: Remove typedef net::URLRequest URLRequest;

webkit/appcache/appcache_update_job.cc

 // 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.
 
 #include "webkit/appcache/appcache_update_job.h"
 
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "webkit/appcache/appcache_group.h"
 #include "webkit/appcache/appcache_policy.h"
 
 namespace appcache {
 
 static const int kBufferSize = 32768;
 static const size_t kMaxConcurrentUrlFetches = 2;
 static const int kMax503Retries = 3;
 
 // Extra info associated with requests for use during response processing.
-// This info is deleted when the URLRequest is deleted.
-class UpdateJobInfo :  public URLRequest::UserData {
+// This info is deleted when the net::URLRequest is deleted.
+class UpdateJobInfo :  public net::URLRequest::UserData {
  public:
   enum RequestType {
     MANIFEST_FETCH,
     URL_FETCH,
     MASTER_ENTRY_FETCH,
     MANIFEST_REFETCH,
   };
 
   explicit UpdateJobInfo(RequestType request_type)
       : type_(request_type),
         buffer_(new net::IOBuffer(kBufferSize)),
         retry_503_attempts_(0),
         update_job_(NULL),
         request_(NULL),
         ALLOW_THIS_IN_INITIALIZER_LIST(write_callback_(
             this, &UpdateJobInfo::OnWriteComplete)) {
   }
 
   void SetUpResponseWriter(AppCacheResponseWriter* writer,
                            AppCacheUpdateJob* update,
-                           URLRequest* request) {
+                           net::URLRequest* request) {
     DCHECK(!response_writer_.get());
     response_writer_.reset(writer);
     update_job_ = update;
     request_ = request;
   }
 
   void OnWriteComplete(int result) {
     // A completed write may delete the URL request and this object.
     update_job_->OnWriteResponseComplete(result, request_, this);
   }
 
   RequestType type_;
   scoped_refptr<net::IOBuffer> buffer_;
   int retry_503_attempts_;
 
   // The entry from the newest cache for this url, used for 304 responses.
   AppCacheEntry existing_entry_;
 
   // Info needed to write responses to storage and process callbacks.
   scoped_ptr<AppCacheResponseWriter> response_writer_;
   AppCacheUpdateJob* update_job_;
-  URLRequest* request_;
+  net::URLRequest* request_;
   net::CompletionCallbackImpl<UpdateJobInfo> write_callback_;
 };
 
 // Helper class for collecting hosts per frontend when sending notifications
 // so that only one notification is sent for all hosts using the same frontend.
 class HostNotifier {
  public:
   typedef std::vector<int> HostIds;
   typedef std::map<AppCacheFrontend*, HostIds> NotifyHostMap;
 
@@ skipping 86 matching lines @@
   DCHECK(!inprogress_cache_);
   DCHECK(pending_master_entries_.empty());
   DCHECK(master_entry_fetches_.empty());
 
   if (group_)
     group_->SetUpdateStatus(AppCacheGroup::IDLE);
 
   policy_callback_->Cancel();
 }
 
-UpdateJobInfo* AppCacheUpdateJob::GetUpdateJobInfo(URLRequest* request) {
+UpdateJobInfo* AppCacheUpdateJob::GetUpdateJobInfo(net::URLRequest* request) {
   return static_cast<UpdateJobInfo*>(request->GetUserData(this));
 }
 
 void AppCacheUpdateJob::StartUpdate(AppCacheHost* host,
                                     const GURL& new_master_resource) {
   DCHECK(group_->update_job() == this);
   DCHECK(!group_->is_obsolete());
 
   bool is_new_pending_master_entry = false;
   if (!new_master_resource.is_empty()) {
@@ skipping 92 matching lines @@
   CancelAllUrlFetches();
   CancelAllMasterEntryFetches(error_message);
   NotifyAllError(error_message);
   DiscardInprogressCache();
   internal_state_ = COMPLETED;
   DeleteSoon();  // To unwind the stack prior to deletion.
 }
 
 void AppCacheUpdateJob::FetchManifest(bool is_first_fetch) {
   DCHECK(!manifest_url_request_);
-  manifest_url_request_ = new URLRequest(manifest_url_, this);
+  manifest_url_request_ = new net::URLRequest(manifest_url_, this);
   UpdateJobInfo::RequestType fetch_type = is_first_fetch ?
       UpdateJobInfo::MANIFEST_FETCH : UpdateJobInfo::MANIFEST_REFETCH;
   manifest_url_request_->SetUserData(this, new UpdateJobInfo(fetch_type));
   manifest_url_request_->set_context(service_->request_context());
   manifest_url_request_->set_load_flags(
       manifest_url_request_->load_flags() | net::LOAD_DISABLE_INTERCEPT);
 
   // Add any necessary Http headers before sending fetch request.
   if (is_first_fetch) {
     AppCacheEntry* entry = (update_type_ == UPGRADE_ATTEMPT) ?
         group_->newest_complete_cache()->GetEntry(manifest_url_) : NULL;
     if (entry) {
       // Asynchronously load response info for manifest from newest cache.
       service_->storage()->LoadResponseInfo(manifest_url_,
                                             entry->response_id(), this);
     } else {
       manifest_url_request_->Start();
     }
   } else {
     DCHECK(internal_state_ == REFETCH_MANIFEST);
     DCHECK(manifest_response_info_.get());
     AddConditionalHeaders(manifest_url_request_,
                           manifest_response_info_.get());
     manifest_url_request_->Start();
   }
 }
 
 void AppCacheUpdateJob::AddConditionalHeaders(
-    URLRequest* request, const net::HttpResponseInfo* info) {
+    net::URLRequest* request, const net::HttpResponseInfo* info) {
   DCHECK(request && info);
   net::HttpRequestHeaders extra_headers;
 
   // Add If-Modified-Since header if response info has Last-Modified header.
   const std::string last_modified = "Last-Modified";
   std::string last_modified_value;
   info->headers->EnumerateHeader(NULL, last_modified, &last_modified_value);
   if (!last_modified_value.empty()) {
     extra_headers.SetHeader(net::HttpRequestHeaders::kIfModifiedSince,
                             last_modified_value);
   }
 
   // Add If-None-Match header if resposne info has ETag header.
   const std::string etag = "ETag";
   std::string etag_value;
   info->headers->EnumerateHeader(NULL, etag, &etag_value);
   if (!etag_value.empty()) {
     extra_headers.SetHeader(net::HttpRequestHeaders::kIfNoneMatch,
                             etag_value);
   }
   if (!extra_headers.IsEmpty())
     request->SetExtraRequestHeaders(extra_headers);
 }
 
-void AppCacheUpdateJob::OnResponseStarted(URLRequest *request) {
+void AppCacheUpdateJob::OnResponseStarted(net::URLRequest *request) {
   if (request->status().is_success() &&
       (request->GetResponseCode() / 100) == 2) {
     // Write response info to storage for URL fetches. Wait for async write
     // completion before reading any response data.
     UpdateJobInfo* info = GetUpdateJobInfo(request);
     if (info->type_ == UpdateJobInfo::URL_FETCH ||
         info->type_ == UpdateJobInfo::MASTER_ENTRY_FETCH) {
       info->SetUpResponseWriter(
           service_->storage()->CreateResponseWriter(manifest_url_),
           this, request);
       stored_response_ids_.push_back(info->response_writer_->response_id());
       scoped_refptr<HttpResponseInfoIOBuffer> io_buffer(
           new HttpResponseInfoIOBuffer(
               new net::HttpResponseInfo(request->response_info())));
       info->response_writer_->WriteInfo(io_buffer, &info->write_callback_);
     } else {
       ReadResponseData(request);
     }
   } else {
     OnResponseCompleted(request);
   }
 }
 
-void AppCacheUpdateJob::ReadResponseData(URLRequest* request) {
+void AppCacheUpdateJob::ReadResponseData(net::URLRequest* request) {
   if (internal_state_ == CACHE_FAILURE || internal_state_ == CANCELLED ||
       internal_state_ == COMPLETED) {
     return;
   }
 
   int bytes_read = 0;
   UpdateJobInfo* info = GetUpdateJobInfo(request);
   request->Read(info->buffer_, kBufferSize, &bytes_read);
   OnReadCompleted(request, bytes_read);
 }
 
-void AppCacheUpdateJob::OnReadCompleted(URLRequest* request, int bytes_read) {
+void AppCacheUpdateJob::OnReadCompleted(net::URLRequest* request,
+                                        int bytes_read) {
   bool data_consumed = true;
   if (request->status().is_success() && bytes_read > 0) {
     UpdateJobInfo* info = GetUpdateJobInfo(request);
     data_consumed = ConsumeResponseData(request, info, bytes_read);
     if (data_consumed) {
       bytes_read = 0;
       while (request->Read(info->buffer_, kBufferSize, &bytes_read)) {
         if (bytes_read > 0) {
           data_consumed = ConsumeResponseData(request, info, bytes_read);
           if (!data_consumed)
             break;  // wait for async data processing, then read more
         } else {
           break;
         }
       }
     }
   }
 
   if (data_consumed && !request->status().is_io_pending())
     OnResponseCompleted(request);
 }
 
-bool AppCacheUpdateJob::ConsumeResponseData(URLRequest* request,
+bool AppCacheUpdateJob::ConsumeResponseData(net::URLRequest* request,
                                             UpdateJobInfo* info,
                                             int bytes_read) {
   DCHECK_GT(bytes_read, 0);
   switch (info->type_) {
     case UpdateJobInfo::MANIFEST_FETCH:
       manifest_data_.append(info->buffer_->data(), bytes_read);
       break;
     case UpdateJobInfo::URL_FETCH:
     case UpdateJobInfo::MASTER_ENTRY_FETCH:
       DCHECK(info->response_writer_.get());
       info->response_writer_->WriteData(info->buffer_, bytes_read,
                                         &info->write_callback_);
       return false;  // wait for async write completion to continue reading
     case UpdateJobInfo::MANIFEST_REFETCH:
       manifest_refetch_data_.append(info->buffer_->data(), bytes_read);
       break;
     default:
       NOTREACHED();
   }
   return true;
 }
 
 void AppCacheUpdateJob::OnWriteResponseComplete(int result,
-                                                URLRequest* request,
+                                                net::URLRequest* request,
                                                 UpdateJobInfo* info) {
   if (result < 0) {
     request->Cancel();
     OnResponseCompleted(request);
     return;
   }
 
   ReadResponseData(request);
 }
 
-void AppCacheUpdateJob::OnReceivedRedirect(URLRequest* request,
+void AppCacheUpdateJob::OnReceivedRedirect(net::URLRequest* request,
                                            const GURL& new_url,
                                            bool* defer_redirect) {
   // Redirect is not allowed by the update process.
   request->Cancel();
   OnResponseCompleted(request);
 }
 
-void AppCacheUpdateJob::OnResponseCompleted(URLRequest* request) {
+void AppCacheUpdateJob::OnResponseCompleted(net::URLRequest* request) {
   // Retry for 503s where retry-after is 0.
   if (request->status().is_success() &&
       request->GetResponseCode() == 503 &&
       RetryRequest(request)) {
     return;
   }
 
   UpdateJobInfo* info = GetUpdateJobInfo(request);
   switch (info->type_) {
     case UpdateJobInfo::MANIFEST_FETCH:
       HandleManifestFetchCompleted(request);
       break;
     case UpdateJobInfo::URL_FETCH:
       HandleUrlFetchCompleted(request);
       break;
     case UpdateJobInfo::MASTER_ENTRY_FETCH:
       HandleMasterEntryFetchCompleted(request);
       break;
     case UpdateJobInfo::MANIFEST_REFETCH:
       HandleManifestRefetchCompleted(request);
       break;
     default:
       NOTREACHED();
   }
 
   delete request;
 }
 
-bool AppCacheUpdateJob::RetryRequest(URLRequest* request) {
+bool AppCacheUpdateJob::RetryRequest(net::URLRequest* request) {
   UpdateJobInfo* info = GetUpdateJobInfo(request);
   if (info->retry_503_attempts_ >= kMax503Retries) {
     return false;
   }
 
   if (!request->response_headers()->HasHeaderValue("retry-after", "0"))
     return false;
 
   const GURL& url = request->original_url();
-  URLRequest* retry = new URLRequest(url, this);
+  net::URLRequest* retry = new net::URLRequest(url, this);
   UpdateJobInfo* retry_info = new UpdateJobInfo(info->type_);
   retry_info->retry_503_attempts_ = info->retry_503_attempts_ + 1;
   retry_info->existing_entry_ = info->existing_entry_;
   retry->SetUserData(this, retry_info);
   retry->set_context(request->context());
   retry->set_load_flags(request->load_flags());
 
   switch (info->type_) {
     case UpdateJobInfo::MANIFEST_FETCH:
     case UpdateJobInfo::MANIFEST_REFETCH:
@@ skipping 11 matching lines @@
     default:
       NOTREACHED();
   }
 
   retry->Start();
 
   delete request;
   return true;
 }
 
-void AppCacheUpdateJob::HandleManifestFetchCompleted(URLRequest* request) {
+void AppCacheUpdateJob::HandleManifestFetchCompleted(net::URLRequest* request) {
   DCHECK(internal_state_ == FETCH_MANIFEST);
   manifest_url_request_ = NULL;
 
   int response_code = -1;
   std::string mime_type;
   bool is_valid_response_code = false;
   bool is_valid_mime_type = false;
   if (request->status().is_success()) {
     response_code = request->GetResponseCode();
     is_valid_response_code = (response_code / 100 == 2);
@@ skipping 86 matching lines @@
     }
   }
 
   group_->SetUpdateStatus(AppCacheGroup::DOWNLOADING);
   NotifyAllAssociatedHosts(DOWNLOADING_EVENT);
   FetchUrls();
   FetchMasterEntries();
   MaybeCompleteUpdate();  // if not done, continues when async fetches complete
 }
 
-void AppCacheUpdateJob::HandleUrlFetchCompleted(URLRequest* request) {
+void AppCacheUpdateJob::HandleUrlFetchCompleted(net::URLRequest* request) {
   DCHECK(internal_state_ == DOWNLOADING);
   UpdateJobInfo* info = GetUpdateJobInfo(request);
 
   const GURL& url = request->original_url();
   pending_url_fetches_.erase(url);
   NotifyAllProgress(url);
   ++url_fetches_completed_;
 
   int response_code = request->status().is_success()
       ? request->GetResponseCode() : -1;
@@ skipping 42 matching lines @@
       inprogress_cache_->AddOrModifyEntry(url, entry);
     }
   }
 
   // Fetch another URL now that one request has completed.
   DCHECK(internal_state_ != CACHE_FAILURE);
   FetchUrls();
   MaybeCompleteUpdate();
 }
 
-void AppCacheUpdateJob::HandleMasterEntryFetchCompleted(URLRequest* request) {
+void AppCacheUpdateJob::HandleMasterEntryFetchCompleted(
+    net::URLRequest* request) {
   DCHECK(internal_state_ == NO_UPDATE || internal_state_ == DOWNLOADING);
 
   // TODO(jennb): Handle downloads completing during cache failure when update
   // no longer fetches master entries directly. For now, we cancel all pending
   // master entry fetches when entering cache failure state so this will never
   // be called in CACHE_FAILURE state.
 
   const GURL& url = request->original_url();
   master_entry_fetches_.erase(url);
   ++master_entries_completed_;
@@ skipping 62 matching lines @@
         return;
       }
     }
   }
 
   DCHECK(internal_state_ != CACHE_FAILURE);
   FetchMasterEntries();
   MaybeCompleteUpdate();
 }
 
-void AppCacheUpdateJob::HandleManifestRefetchCompleted(URLRequest* request) {
+void AppCacheUpdateJob::HandleManifestRefetchCompleted(
+    net::URLRequest* request) {
   DCHECK(internal_state_ == REFETCH_MANIFEST);
   manifest_url_request_ = NULL;
 
   int response_code = request->status().is_success()
       ? request->GetResponseCode() : -1;
   if (response_code == 304 || manifest_data_ == manifest_refetch_data_) {
     // Only need to store response in storage if manifest is not already
     // an entry in the cache.
     AppCacheEntry* entry = inprogress_cache_->GetEntry(manifest_url_);
     if (entry) {
@@ skipping 233 matching lines @@
         AppCacheEntry* existing_entry =
             group_->newest_complete_cache()->GetEntry(url_to_fetch.url);
         DCHECK(existing_entry);
         DCHECK(existing_entry->response_id() ==
                url_to_fetch.existing_response_info->response_id());
         info->existing_entry_ = *existing_entry;
         http_info = url_to_fetch.existing_response_info->http_response_info();
       }
 
       // Send URL request for the resource.
-      URLRequest* request = new URLRequest(url_to_fetch.url, this);
+      net::URLRequest* request = new net::URLRequest(url_to_fetch.url, this);
       request->SetUserData(this, info);
       request->set_context(service_->request_context());
       request->set_load_flags(
           request->load_flags() | net::LOAD_DISABLE_INTERCEPT);
       if (http_info)
         AddConditionalHeaders(request, http_info);
       request->Start();
       pending_url_fetches_.insert(
           PendingUrlFetches::value_type(url_to_fetch.url, request));
     }
@@ skipping 94 matching lines @@
         PendingMasters::iterator found = pending_master_entries_.find(url);
         DCHECK(found != pending_master_entries_.end());
         PendingHosts& hosts = found->second;
         for (PendingHosts::iterator host_it = hosts.begin();
              host_it != hosts.end(); ++host_it) {
           (*host_it)->AssociateCache(cache);
         }
       }
     } else {
       // Send URL request for the master entry.
-      URLRequest* request = new URLRequest(url, this);
+      net::URLRequest* request = new net::URLRequest(url, this);
       request->SetUserData(this,
           new UpdateJobInfo(UpdateJobInfo::MASTER_ENTRY_FETCH));
       request->set_context(service_->request_context());
       request->set_load_flags(
           request->load_flags() | net::LOAD_DISABLE_INTERCEPT);
       request->Start();
       master_entry_fetches_.insert(PendingUrlFetches::value_type(url, request));
     }
 
     master_entries_to_fetch_.erase(master_entries_to_fetch_.begin());
@@ skipping 257 matching lines @@
 
   // Break the connection with the group so the group cannot call delete
   // on this object after we've posted a task to delete ourselves.
   group_->SetUpdateStatus(AppCacheGroup::IDLE);
   group_ = NULL;
 
   MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
 }  // namespace appcache