NavigationController prototype

webkit/browser/appcache/appcache_update_job.cc

 // Copyright (c) 2012 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/browser/appcache/appcache_update_job.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 284 matching lines @@
 AppCacheUpdateJob::AppCacheUpdateJob(AppCacheService* service,
                                      AppCacheGroup* group)
     : service_(service),
       manifest_url_(group->manifest_url()),
       group_(group),
       update_type_(UNKNOWN_TYPE),
       internal_state_(FETCH_MANIFEST),
       master_entries_completed_(0),
       url_fetches_completed_(0),
       manifest_fetcher_(NULL),
-      stored_state_(UNSTORED) {
+      stored_state_(UNSTORED),
+      using_fake_manifest_(false) {
 }
 
 AppCacheUpdateJob::~AppCacheUpdateJob() {
   if (internal_state_ != COMPLETED)
     Cancel();
 
   DCHECK(!manifest_fetcher_);
   DCHECK(pending_url_fetches_.empty());
   DCHECK(!inprogress_cache_.get());
   DCHECK(pending_master_entries_.empty());
   DCHECK(master_entry_fetches_.empty());
 
   if (group_)
     group_->SetUpdateStatus(AppCacheGroup::IDLE);
 }
 
 void AppCacheUpdateJob::StartUpdate(AppCacheHost* host,
                                     const GURL& new_master_resource) {
   DCHECK(group_->update_job() == this);
   DCHECK(!group_->is_obsolete());
 
+  // Hackery for 'registerController'
+  if (group_->HasCache() &&
+      !group_->newest_complete_cache()->GetEntry(group_->manifest_url())) {
+    using_fake_manifest_ = true;
+    DeleteSoon();
+    return;
+  }
+
   bool is_new_pending_master_entry = false;
   if (!new_master_resource.is_empty()) {
     DCHECK(new_master_resource == host->pending_master_entry_url());
     DCHECK(!new_master_resource.has_ref());
     DCHECK(new_master_resource.GetOrigin() == manifest_url_.GetOrigin());
 
     // Cannot add more to this update if already terminating.
     if (IsTerminating()) {
       group_->QueueUpdate(host, new_master_resource);
       return;
@@ skipping 37 matching lines @@
   }
 
   if (!new_master_resource.is_empty()) {
     AddMasterEntryToFetchList(host, new_master_resource,
                               is_new_pending_master_entry);
   }
 
   FetchManifest(true);
 }
 
+// Hackery for 'registerController'
+void AppCacheUpdateJob::StartUpdateWithFakeManifest(Manifest* manifest) {
+  DCHECK(group_->update_job() == this);
+  DCHECK(!group_->is_obsolete());
+
+  using_fake_manifest_ = true;
+
+  // Begin the update process for the group.
+  group_->SetUpdateStatus(AppCacheGroup::CHECKING);
+  DCHECK(!group_->HasCache());  // we don't ever 'upgrade' these caches
+  update_type_ = CACHE_ATTEMPT;
+
+  // Jump straight into downloading the controller script.
+  internal_state_ = DOWNLOADING;
+  inprogress_cache_ = new AppCache(service_->storage(),
+                                   service_->storage()->NewCacheId());
+  BuildUrlFileList(*manifest);
+  inprogress_cache_->InitializeWithManifest(manifest);
+  group_->SetUpdateStatus(AppCacheGroup::DOWNLOADING);
+  NotifyAllAssociatedHosts(DOWNLOADING_EVENT);
+  FetchUrls();
+}
+
 AppCacheResponseWriter* AppCacheUpdateJob::CreateResponseWriter() {
   AppCacheResponseWriter* writer =
       service_->storage()->CreateResponseWriter(manifest_url_,
                                                 group_->group_id());
   stored_response_ids_.push_back(writer->response_id());
   return writer;
 }
 
 void AppCacheUpdateJob::HandleCacheFailure(const std::string& error_message) {
   // 6.9.4 cache failure steps 2-8.
@@ skipping 821 matching lines @@
 void AppCacheUpdateJob::MaybeCompleteUpdate() {
   DCHECK(internal_state_ != CACHE_FAILURE);
 
   // Must wait for any pending master entries or url fetches to complete.
   if (master_entries_completed_ != pending_master_entries_.size() ||
       url_fetches_completed_ != url_file_list_.size()) {
     DCHECK(internal_state_ != COMPLETED);
     return;
   }
 
+  // Hackery for 'registerController'
+  if (using_fake_manifest_) {
+    if (stored_state_ == UNSTORED) {
+      // Skip refetching the manifest that does not exist.
+      StoreGroupAndCache();
+      return;
+    }
+    if (stored_state_ == STORING)
+      return;
+    internal_state_ = REFETCH_MANIFEST; // hackery to fallthru to below
+  }
+
   switch (internal_state_) {
     case NO_UPDATE:
       if (master_entries_completed_ > 0) {
         switch (stored_state_) {
           case UNSTORED:
             StoreGroupAndCache();
             return;
           case STORING:
             return;
           case STORED:
@@ skipping 112 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;
 
   base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
 }  // namespace appcache