Add storage code to appcache update process.

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 "base/ref_counted.h"
 #include "base/task.h"
 #include "googleurl/src/gurl.h"
 #include "net/url_request/url_request.h"
 #include "webkit/appcache/appcache.h"
 #include "webkit/appcache/appcache_interfaces.h"
+#include "webkit/appcache/appcache_storage.h"
 
 namespace appcache {
 
-struct UpdateJobInfo;
+class UpdateJobInfo;
 
 // Application cache Update algorithm and state.
-class AppCacheUpdateJob : public URLRequest::Delegate {
+class AppCacheUpdateJob : public URLRequest::Delegate,
+                          public AppCacheStorage::Delegate {
  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);
 
-
-  // TODO(jennb): add callback method for writing data to storage
-  // TODO(jennb): add callback method for reading data from storage
-
  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.
   // TODO(jennb): detect when hosts are deleted
   typedef std::vector<AppCacheHost*> PendingHosts;
   typedef std::map<GURL, PendingHosts> PendingMasters;
   typedef std::map<GURL, URLRequest*> PendingUrlFetches;
   typedef std::pair<GURL, bool> UrlToFetch;  // flag TRUE if storage checked
 
   static const int kRerunDelayMs = 1000;
@@ skipping 15 matching lines @@
   };
 
   // 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);
   // TODO(jennb): any other delegate callbacks to handle? certificate?
 
+  // Methods for AppCacheStorage::Delegate.
+  void OnGroupAndNewestCacheStored(AppCacheGroup* group, bool success);
+  void OnGroupMadeObsolete(AppCacheGroup* group, bool success);
+
   void FetchManifest(bool is_first_fetch);
 
   void OnResponseCompleted(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);
 
   void ReadResponseData(URLRequest* request);
 
   // Returns false if response data is processed asynchronously, in which
-  // case a callback will be invoked when it is safe to continue reading
-  // more response data from the request.
+  // case ReadResponseData will be invoked when it is safe to continue
+  // reading more response data from the request.
   bool ConsumeResponseData(URLRequest* request,
                            UpdateJobInfo* info,
                            int bytes_read);
+  void OnWriteResponseComplete(int result, URLRequest* request,
+                               UpdateJobInfo* info);
 
   void HandleManifestFetchCompleted(URLRequest* request);
   void ContinueHandleManifestFetchCompleted(bool changed);
+
   void HandleUrlFetchCompleted(URLRequest* request);
+
   void HandleManifestRefetchCompleted(URLRequest* request);
+  void OnManifestInfoWriteComplete(int result);
+  void OnManifestDataWriteComplete(int result);
+  void CompleteInprogressCache();
+  void HandleManifestRefetchFailure();
 
   void NotifySingleHost(AppCacheHost* host, EventID event_id);
   void NotifyAllPendingMasterHosts(EventID event_id);
   void NotifyAllAssociatedHosts(EventID event_id);
 
   // Checks if manifest is byte for byte identical with the manifest
   // in the newest application cache.
   void CheckIfManifestChanged();
   void ContinueCheckIfManifestChanged(const std::string& loaded_manifest);
 
@@ skipping 45 matching lines @@
   AppCacheService* service_;
 
   scoped_refptr<AppCache> inprogress_cache_;
 
   // Hold a reference to the newly created cache until this update is
   // destroyed. The host that started the update will add a reference to the
   // new cache when notified that the update is complete. AppCacheGroup sends
   // the notification when its status is set to IDLE in ~AppCacheUpdateJob.
   scoped_refptr<AppCache> protect_new_cache_;
 
+  // Hold a reference to the group's newest cache (prior to update) in order
+  // to restore the group's newest cache if storage fails.
+  scoped_refptr<AppCache> protect_former_newest_cache_;
+
   AppCacheGroup* group_;
 
   UpdateType update_type_;
   InternalUpdateState internal_state_;
 
   PendingMasters pending_master_entries_;
   size_t master_entries_completed_;
 
   // URLs of files to fetch along with their flags.
   AppCache::EntryMap url_file_list_;
   size_t url_fetches_completed_;
 
   // 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_;
 
   // Keep track of pending URL requests so we can cancel them if necessary.
   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_;
+
+  net::CompletionCallbackImpl<AppCacheUpdateJob> manifest_info_write_callback_;
+  net::CompletionCallbackImpl<AppCacheUpdateJob> manifest_data_write_callback_;
 
   // TODO(jennb): delete when able to mock storage behavior
   bool simulate_manifest_changed_;
 
   DISALLOW_COPY_AND_ASSIGN(AppCacheUpdateJob);
 };
 
 }  // namespace appcache
 
 #endif  // WEBKIT_APPCACHE_APPCACHE_UPDATE_JOB_H_