net: Remove typedef net::URLRequest URLRequest;

webkit/appcache/appcache_update_job.h

 // Copyright (c) 2009 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 WEBKIT_APPCACHE_APPCACHE_UPDATE_JOB_H_
 #define WEBKIT_APPCACHE_APPCACHE_UPDATE_JOB_H_
 
 #include <deque>
 #include <map>
 #include <set>
@@ skipping 11 matching lines @@
 #include "webkit/appcache/appcache_interfaces.h"
 #include "webkit/appcache/appcache_response.h"
 #include "webkit/appcache/appcache_storage.h"
 
 namespace appcache {
 
 class UpdateJobInfo;
 class HostNotifier;
 
 // Application cache Update algorithm and state.
-class AppCacheUpdateJob : public URLRequest::Delegate,
+class AppCacheUpdateJob : public net::URLRequest::Delegate,
                           public AppCacheStorage::Delegate,
                           public AppCacheHost::Observer {
  public:
   AppCacheUpdateJob(AppCacheService* service, AppCacheGroup* group);
   ~AppCacheUpdateJob();
 
   // Triggers the update process or adds more info if this update is already
   // in progress.
   void StartUpdate(AppCacheHost* host, const GURL& new_master_resource);
 
  private:
   friend class ScopedRunnableMethodFactory<AppCacheUpdateJob>;
   friend class AppCacheUpdateJobTest;
   friend class UpdateJobInfo;
 
   // Master entries have multiple hosts, for example, the same page is opened
   // in different tabs.
   typedef std::vector<AppCacheHost*> PendingHosts;
   typedef std::map<GURL, PendingHosts> PendingMasters;
-  typedef std::map<GURL, URLRequest*> PendingUrlFetches;
+  typedef std::map<GURL, net::URLRequest*> PendingUrlFetches;
   typedef std::map<int64, GURL> LoadingResponses;
 
   static const int kRerunDelayMs = 1000;
 
   // TODO(michaeln): Rework the set of states vs update types vs stored states.
   // The NO_UPDATE state is really more of an update type. For all update types
   // storing the results is relevant.
 
   enum UpdateType {
     UNKNOWN_TYPE,
@@ skipping 21 matching lines @@
 
   struct UrlToFetch {
     UrlToFetch(const GURL& url, bool checked, AppCacheResponseInfo* info);
     ~UrlToFetch();
 
     GURL url;
     bool storage_checked;
     scoped_refptr<AppCacheResponseInfo> existing_response_info;
   };
 
-  UpdateJobInfo* GetUpdateJobInfo(URLRequest* request);
+  UpdateJobInfo* GetUpdateJobInfo(net::URLRequest* request);
 
-  // Methods for URLRequest::Delegate.
-  void OnResponseStarted(URLRequest* request);
-  void OnReadCompleted(URLRequest* request, int bytes_read);
-  void OnReceivedRedirect(URLRequest* request,
-                          const GURL& new_url,
-                          bool* defer_redirect);
+  // Overridden from net::URLRequest::Delegate:
+  virtual void OnResponseStarted(net::URLRequest* request);
+  virtual void OnReadCompleted(net::URLRequest* request, int bytes_read);
+  virtual void OnReceivedRedirect(net::URLRequest* request,
+                                  const GURL& new_url,
+                                  bool* defer_redirect);
   // TODO(jennb): any other delegate callbacks to handle? certificate?
 
   // Methods for AppCacheStorage::Delegate.
   void OnResponseInfoLoaded(AppCacheResponseInfo* response_info,
                             int64 response_id);
   void OnGroupAndNewestCacheStored(AppCacheGroup* group, AppCache* newest_cache,
                                    bool success, bool would_exceed_quota);
   void OnGroupMadeObsolete(AppCacheGroup* group, bool success);
 
   // Methods for AppCacheHost::Observer.
   void OnCacheSelectionComplete(AppCacheHost* host) {}  // N/A
   void OnDestructionImminent(AppCacheHost* host);
 
   void CheckPolicy();
   void OnPolicyCheckComplete(int rv);
 
   void HandleCacheFailure(const std::string& error_message);
 
   void FetchManifest(bool is_first_fetch);
 
   // Add extra conditional HTTP headers to the request based on the
   // currently cached response headers.
-  void AddConditionalHeaders(URLRequest* request,
+  void AddConditionalHeaders(net::URLRequest* request,
                              const net::HttpResponseInfo* info);
 
-  void OnResponseCompleted(URLRequest* request);
+  void OnResponseCompleted(net::URLRequest* request);
 
   // Retries a 503 request with retry-after header of 0.
   // Returns true if request should be retried and deletes original request.
-  bool RetryRequest(URLRequest* request);
+  bool RetryRequest(net::URLRequest* request);
 
-  void ReadResponseData(URLRequest* request);
+  void ReadResponseData(net::URLRequest* request);
 
   // Returns false if response data is processed asynchronously, in which
   // case ReadResponseData will be invoked when it is safe to continue
   // reading more response data from the request.
-  bool ConsumeResponseData(URLRequest* request,
+  bool ConsumeResponseData(net::URLRequest* request,
                            UpdateJobInfo* info,
                            int bytes_read);
-  void OnWriteResponseComplete(int result, URLRequest* request,
+  void OnWriteResponseComplete(int result, net::URLRequest* request,
                                UpdateJobInfo* info);
 
-  void HandleManifestFetchCompleted(URLRequest* request);
+  void HandleManifestFetchCompleted(net::URLRequest* request);
   void ContinueHandleManifestFetchCompleted(bool changed);
 
-  void HandleUrlFetchCompleted(URLRequest* request);
-  void HandleMasterEntryFetchCompleted(URLRequest* request);
+  void HandleUrlFetchCompleted(net::URLRequest* request);
+  void HandleMasterEntryFetchCompleted(net::URLRequest* request);
 
-  void HandleManifestRefetchCompleted(URLRequest* request);
+  void HandleManifestRefetchCompleted(net::URLRequest* request);
   void OnManifestInfoWriteComplete(int result);
   void OnManifestDataWriteComplete(int result);
 
   void StoreGroupAndCache();
 
   void NotifySingleHost(AppCacheHost* host, EventID event_id);
   void NotifyAllAssociatedHosts(EventID event_id);
   void NotifyAllProgress(const GURL& url);
   void NotifyAllFinalProgress();
   void NotifyAllError(const std::string& error_message);
@@ skipping 84 matching lines @@
   // Helper container to track which urls have not been fetched yet. URLs are
   // removed when the fetch is initiated. Flag indicates whether an attempt
   // to load the URL from storage has already been tried and failed.
   std::deque<UrlToFetch> urls_to_fetch_;
 
   // Helper container to track which urls are being loaded from response
   // storage.
   LoadingResponses loading_responses_;
 
   // Keep track of pending URL requests so we can cancel them if necessary.
-  URLRequest* manifest_url_request_;
+  net::URLRequest* manifest_url_request_;
   PendingUrlFetches pending_url_fetches_;
 
   // Temporary storage of manifest response data for parsing and comparison.
   std::string manifest_data_;
   std::string manifest_refetch_data_;
   scoped_ptr<net::HttpResponseInfo> manifest_response_info_;
   scoped_ptr<AppCacheResponseWriter> manifest_response_writer_;
   scoped_refptr<net::IOBuffer> read_manifest_buffer_;
   std::string loaded_manifest_data_;
   scoped_ptr<AppCacheResponseReader> manifest_response_reader_;
@@ skipping 24 matching lines @@
       policy_callback_;
 
   FRIEND_TEST_ALL_PREFIXES(AppCacheGroupTest, QueueUpdate);
 
   DISALLOW_COPY_AND_ASSIGN(AppCacheUpdateJob);
 };
 
 }  // namespace appcache
 
 #endif  // WEBKIT_APPCACHE_APPCACHE_UPDATE_JOB_H_