webkit/browser/appcache/appcache_update_job.h

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