Home | History | Annotate | Download | only in appcache 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef WEBKIT_BROWSER_APPCACHE_APPCACHE_UPDATE_JOB_H_
      6 #define WEBKIT_BROWSER_APPCACHE_APPCACHE_UPDATE_JOB_H_
      7 
      8 #include <deque>
      9 #include <map>
     10 #include <set>
     11 #include <string>
     12 #include <vector>
     13 
     14 #include "base/gtest_prod_util.h"
     15 #include "base/memory/ref_counted.h"
     16 #include "net/base/completion_callback.h"
     17 #include "net/http/http_response_headers.h"
     18 #include "net/url_request/url_request.h"
     19 #include "url/gurl.h"
     20 #include "webkit/browser/appcache/appcache.h"
     21 #include "webkit/browser/appcache/appcache_host.h"
     22 #include "webkit/browser/appcache/appcache_response.h"
     23 #include "webkit/browser/appcache/appcache_storage.h"
     24 #include "webkit/browser/webkit_storage_browser_export.h"
     25 #include "webkit/common/appcache/appcache_interfaces.h"
     26 
     27 namespace appcache {
     28 
     29 class HostNotifier;
     30 
     31 // Application cache Update algorithm and state.
     32 class WEBKIT_STORAGE_BROWSER_EXPORT AppCacheUpdateJob
     33     : public AppCacheStorage::Delegate,
     34       public AppCacheHost::Observer {
     35  public:
     36   AppCacheUpdateJob(AppCacheService* service, AppCacheGroup* group);
     37   virtual ~AppCacheUpdateJob();
     38 
     39   // Triggers the update process or adds more info if this update is already
     40   // in progress.
     41   void StartUpdate(AppCacheHost* host, const GURL& new_master_resource);
     42 
     43  private:
     44   friend class AppCacheUpdateJobTest;
     45   class URLFetcher;
     46 
     47   // Master entries have multiple hosts, for example, the same page is opened
     48   // in different tabs.
     49   typedef std::vector<AppCacheHost*> PendingHosts;
     50   typedef std::map<GURL, PendingHosts> PendingMasters;
     51   typedef std::map<GURL, URLFetcher*> PendingUrlFetches;
     52   typedef std::map<int64, GURL> LoadingResponses;
     53 
     54   static const int kRerunDelayMs = 1000;
     55 
     56   // TODO(michaeln): Rework the set of states vs update types vs stored states.
     57   // The NO_UPDATE state is really more of an update type. For all update types
     58   // storing the results is relevant.
     59 
     60   enum UpdateType {
     61     UNKNOWN_TYPE,
     62     UPGRADE_ATTEMPT,
     63     CACHE_ATTEMPT,
     64   };
     65 
     66   enum InternalUpdateState {
     67     FETCH_MANIFEST,
     68     NO_UPDATE,
     69     DOWNLOADING,
     70 
     71     // Every state after this comment indicates the update is terminating.
     72     REFETCH_MANIFEST,
     73     CACHE_FAILURE,
     74     CANCELLED,
     75     COMPLETED,
     76   };
     77 
     78   enum StoredState {
     79     UNSTORED,
     80     STORING,
     81     STORED,
     82   };
     83 
     84   struct UrlToFetch {
     85     UrlToFetch(const GURL& url, bool checked, AppCacheResponseInfo* info);
     86     ~UrlToFetch();
     87 
     88     GURL url;
     89     bool storage_checked;
     90     scoped_refptr<AppCacheResponseInfo> existing_response_info;
     91   };
     92 
     93   class URLFetcher : public net::URLRequest::Delegate {
     94    public:
     95     enum FetchType {
     96       MANIFEST_FETCH,
     97       URL_FETCH,
     98       MASTER_ENTRY_FETCH,
     99       MANIFEST_REFETCH,
    100     };
    101     URLFetcher(const GURL& url,
    102                FetchType fetch_type,
    103                AppCacheUpdateJob* job);
    104     virtual ~URLFetcher();
    105     void Start();
    106     FetchType fetch_type() const { return fetch_type_; }
    107     net::URLRequest* request() const { return request_.get(); }
    108     const AppCacheEntry& existing_entry() const { return existing_entry_; }
    109     const std::string& manifest_data() const { return manifest_data_; }
    110     AppCacheResponseWriter* response_writer() const {
    111       return response_writer_.get();
    112     }
    113     void set_existing_response_headers(net::HttpResponseHeaders* headers) {
    114       existing_response_headers_ = headers;
    115     }
    116     void set_existing_entry(const AppCacheEntry& entry) {
    117       existing_entry_ = entry;
    118     }
    119 
    120    private:
    121     // URLRequest::Delegate overrides
    122     virtual void OnReceivedRedirect(net::URLRequest* request,
    123                                     const GURL& new_url,
    124                                     bool* defer_redirect) OVERRIDE;
    125     virtual void OnResponseStarted(net::URLRequest* request) OVERRIDE;
    126     virtual void OnReadCompleted(net::URLRequest* request,
    127                                  int bytes_read) OVERRIDE;
    128 
    129     void AddConditionalHeaders(const net::HttpResponseHeaders* headers);
    130     void OnWriteComplete(int result);
    131     void ReadResponseData();
    132     bool ConsumeResponseData(int bytes_read);
    133     void OnResponseCompleted();
    134     bool MaybeRetryRequest();
    135 
    136     GURL url_;
    137     AppCacheUpdateJob* job_;
    138     FetchType fetch_type_;
    139     int retry_503_attempts_;
    140     scoped_refptr<net::IOBuffer> buffer_;
    141     scoped_ptr<net::URLRequest> request_;
    142     AppCacheEntry existing_entry_;
    143     scoped_refptr<net::HttpResponseHeaders> existing_response_headers_;
    144     std::string manifest_data_;
    145     scoped_ptr<AppCacheResponseWriter> response_writer_;
    146   };  // class URLFetcher
    147 
    148   AppCacheResponseWriter* CreateResponseWriter();
    149 
    150   // Methods for AppCacheStorage::Delegate.
    151   virtual void OnResponseInfoLoaded(AppCacheResponseInfo* response_info,
    152                                     int64 response_id) OVERRIDE;
    153   virtual void OnGroupAndNewestCacheStored(AppCacheGroup* group,
    154                                            AppCache* newest_cache,
    155                                            bool success,
    156                                            bool would_exceed_quota) OVERRIDE;
    157   virtual void OnGroupMadeObsolete(AppCacheGroup* group, bool success) OVERRIDE;
    158 
    159   // Methods for AppCacheHost::Observer.
    160   virtual void OnCacheSelectionComplete(AppCacheHost* host) OVERRIDE {}  // N/A
    161   virtual void OnDestructionImminent(AppCacheHost* host) OVERRIDE;
    162 
    163   void HandleCacheFailure(const std::string& error_message);
    164 
    165   void FetchManifest(bool is_first_fetch);
    166   void HandleManifestFetchCompleted(URLFetcher* fetcher);
    167   void ContinueHandleManifestFetchCompleted(bool changed);
    168 
    169   void HandleUrlFetchCompleted(URLFetcher* fetcher);
    170   void HandleMasterEntryFetchCompleted(URLFetcher* fetcher);
    171 
    172   void HandleManifestRefetchCompleted(URLFetcher* fetcher);
    173   void OnManifestInfoWriteComplete(int result);
    174   void OnManifestDataWriteComplete(int result);
    175 
    176   void StoreGroupAndCache();
    177 
    178   void NotifySingleHost(AppCacheHost* host, EventID event_id);
    179   void NotifyAllAssociatedHosts(EventID event_id);
    180   void NotifyAllProgress(const GURL& url);
    181   void NotifyAllFinalProgress();
    182   void NotifyAllError(const std::string& error_message);
    183   void AddAllAssociatedHostsToNotifier(HostNotifier* notifier);
    184 
    185   // Checks if manifest is byte for byte identical with the manifest
    186   // in the newest application cache.
    187   void CheckIfManifestChanged();
    188   void OnManifestDataReadComplete(int result);
    189 
    190   // Creates the list of files that may need to be fetched and initiates
    191   // fetches. Section 6.9.4 steps 12-17
    192   void BuildUrlFileList(const Manifest& manifest);
    193   void AddUrlToFileList(const GURL& url, int type);
    194   void FetchUrls();
    195   void CancelAllUrlFetches();
    196   bool ShouldSkipUrlFetch(const AppCacheEntry& entry);
    197 
    198   // If entry already exists in the cache currently being updated, merge
    199   // the entry type information with the existing entry.
    200   // Returns true if entry exists in cache currently being updated.
    201   bool AlreadyFetchedEntry(const GURL& url, int entry_type);
    202 
    203   // TODO(jennb): Delete when update no longer fetches master entries directly.
    204   // Creates the list of master entries that need to be fetched and initiates
    205   // fetches.
    206   void AddMasterEntryToFetchList(AppCacheHost* host, const GURL& url,
    207                                  bool is_new);
    208   void FetchMasterEntries();
    209   void CancelAllMasterEntryFetches(const std::string& error_message);
    210 
    211   // Asynchronously loads the entry from the newest complete cache if the
    212   // HTTP caching semantics allow.
    213   // Returns false if immediately obvious that data cannot be loaded from
    214   // newest complete cache.
    215   bool MaybeLoadFromNewestCache(const GURL& url, AppCacheEntry& entry);
    216   void LoadFromNewestCacheFailed(const GURL& url,
    217                                  AppCacheResponseInfo* newest_response_info);
    218 
    219   // Does nothing if update process is still waiting for pending master
    220   // entries or URL fetches to complete downloading. Otherwise, completes
    221   // the update process.
    222   void MaybeCompleteUpdate();
    223 
    224   // Schedules a rerun of the entire update with the same parameters as
    225   // this update job after a short delay.
    226   void ScheduleUpdateRetry(int delay_ms);
    227 
    228   void Cancel();
    229   void ClearPendingMasterEntries();
    230   void DiscardInprogressCache();
    231   void DiscardDuplicateResponses();
    232 
    233   // Deletes this object after letting the stack unwind.
    234   void DeleteSoon();
    235 
    236   bool IsTerminating() { return internal_state_ >= REFETCH_MANIFEST ||
    237                                 stored_state_ != UNSTORED; }
    238 
    239   AppCacheService* service_;
    240   const GURL manifest_url_;  // here for easier access
    241 
    242   scoped_refptr<AppCache> inprogress_cache_;
    243 
    244   AppCacheGroup* group_;
    245 
    246   UpdateType update_type_;
    247   InternalUpdateState internal_state_;
    248 
    249   PendingMasters pending_master_entries_;
    250   size_t master_entries_completed_;
    251 
    252   // TODO(jennb): Delete when update no longer fetches master entries directly.
    253   // Helper containers to track which pending master entries have yet to be
    254   // fetched and which are currently being fetched. Master entries that
    255   // are listed in the manifest may be fetched as a regular URL instead of
    256   // as a separate master entry fetch to optimize against duplicate fetches.
    257   std::set<GURL> master_entries_to_fetch_;
    258   PendingUrlFetches master_entry_fetches_;
    259 
    260   // URLs of files to fetch along with their flags.
    261   AppCache::EntryMap url_file_list_;
    262   size_t url_fetches_completed_;
    263 
    264   // Helper container to track which urls have not been fetched yet. URLs are
    265   // removed when the fetch is initiated. Flag indicates whether an attempt
    266   // to load the URL from storage has already been tried and failed.
    267   std::deque<UrlToFetch> urls_to_fetch_;
    268 
    269   // Helper container to track which urls are being loaded from response
    270   // storage.
    271   LoadingResponses loading_responses_;
    272 
    273   // Keep track of pending URL requests so we can cancel them if necessary.
    274   URLFetcher* manifest_fetcher_;
    275   PendingUrlFetches pending_url_fetches_;
    276 
    277   // Temporary storage of manifest response data for parsing and comparison.
    278   std::string manifest_data_;
    279   scoped_ptr<net::HttpResponseInfo> manifest_response_info_;
    280   scoped_ptr<AppCacheResponseWriter> manifest_response_writer_;
    281   scoped_refptr<net::IOBuffer> read_manifest_buffer_;
    282   std::string loaded_manifest_data_;
    283   scoped_ptr<AppCacheResponseReader> manifest_response_reader_;
    284 
    285   // New master entries added to the cache by this job, used to cleanup
    286   // in error conditions.
    287   std::vector<GURL> added_master_entries_;
    288 
    289   // Response ids stored by this update job, used to cleanup in
    290   // error conditions.
    291   std::vector<int64> stored_response_ids_;
    292 
    293   // In some cases we fetch the same resource multiple times, and then
    294   // have to delete the duplicates upon successful update. These ids
    295   // are also in the stored_response_ids_ collection so we only schedule
    296   // these for deletion on success.
    297   // TODO(michaeln): Rework when we no longer fetches master entries directly.
    298   std::vector<int64> duplicate_response_ids_;
    299 
    300   // Whether we've stored the resulting group/cache yet.
    301   StoredState stored_state_;
    302 
    303   FRIEND_TEST_ALL_PREFIXES(AppCacheGroupTest, QueueUpdate);
    304 
    305   DISALLOW_COPY_AND_ASSIGN(AppCacheUpdateJob);
    306 };
    307 
    308 }  // namespace appcache
    309 
    310 #endif  // WEBKIT_BROWSER_APPCACHE_APPCACHE_UPDATE_JOB_H_
    311