Rename some appcache types in preparation for moving to content namespace

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 40 matching lines @@
     ret.first->second.push_back(host->host_id());
   }
 
   void AddHosts(const std::set<AppCacheHost*>& hosts) {
     for (std::set<AppCacheHost*>::const_iterator it = hosts.begin();
          it != hosts.end(); ++it) {
       AddHost(*it);
     }
   }
 
-  void SendNotifications(EventID event_id) {
+  void SendNotifications(AppCacheEventID event_id) {
     for (NotifyHostMap::iterator it = hosts_to_notify.begin();
          it != hosts_to_notify.end(); ++it) {
       AppCacheFrontend* frontend = it->first;
       frontend->OnEventRaised(it->second, event_id);
     }
   }
 
   void SendProgressNotifications(
       const GURL& url, int num_total, int num_complete) {
     for (NotifyHostMap::iterator it = hosts_to_notify.begin();
          it != hosts_to_notify.end(); ++it) {
       AppCacheFrontend* frontend = it->first;
       frontend->OnProgressEventRaised(it->second, url,
                                       num_total, num_complete);
     }
   }
 
-  void SendErrorNotifications(const ErrorDetails& details) {
+  void SendErrorNotifications(const AppCacheErrorDetails& details) {
     DCHECK(!details.message.empty());
     for (NotifyHostMap::iterator it = hosts_to_notify.begin();
          it != hosts_to_notify.end(); ++it) {
       AppCacheFrontend* frontend = it->first;
       frontend->OnErrorEventRaised(it->second, details);
     }
   }
 
   void SendLogMessage(const std::string& message) {
     for (NotifyHostMap::iterator it = hosts_to_notify.begin();
@@ skipping 272 matching lines @@
   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);
+    group_->SetUpdateAppCacheStatus(AppCacheGroup::IDLE);
 }
 
 void AppCacheUpdateJob::StartUpdate(AppCacheHost* host,
                                     const GURL& new_master_resource) {
   DCHECK(group_->update_job() == this);
   DCHECK(!group_->is_obsolete());
 
   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;
     }
 
     std::pair<PendingMasters::iterator, bool> ret =
         pending_master_entries_.insert(
             PendingMasters::value_type(new_master_resource, PendingHosts()));
     is_new_pending_master_entry = ret.second;
     ret.first->second.push_back(host);
     host->AddObserver(this);
   }
 
   // Notify host (if any) if already checking or downloading.
-  AppCacheGroup::UpdateStatus update_status = group_->update_status();
+  AppCacheGroup::UpdateAppCacheStatus update_status = group_->update_status();
   if (update_status == AppCacheGroup::CHECKING ||
       update_status == AppCacheGroup::DOWNLOADING) {
     if (host) {
       NotifySingleHost(host, CHECKING_EVENT);
       if (update_status == AppCacheGroup::DOWNLOADING)
         NotifySingleHost(host, DOWNLOADING_EVENT);
 
       // Add to fetch list or an existing entry if already fetched.
       if (!new_master_resource.is_empty()) {
         AddMasterEntryToFetchList(host, new_master_resource,
                                   is_new_pending_master_entry);
       }
     }
     return;
   }
 
   // Begin update process for the group.
   MadeProgress();
-  group_->SetUpdateStatus(AppCacheGroup::CHECKING);
+  group_->SetUpdateAppCacheStatus(AppCacheGroup::CHECKING);
   if (group_->HasCache()) {
     update_type_ = UPGRADE_ATTEMPT;
     NotifyAllAssociatedHosts(CHECKING_EVENT);
   } else {
     update_type_ = CACHE_ATTEMPT;
     DCHECK(host);
     NotifySingleHost(host, CHECKING_EVENT);
   }
 
   if (!new_master_resource.is_empty()) {
     AddMasterEntryToFetchList(host, new_master_resource,
                               is_new_pending_master_entry);
   }
 
   FetchManifest(true);
 }
 
 AppCacheResponseWriter* AppCacheUpdateJob::CreateResponseWriter() {
   AppCacheResponseWriter* writer =
       storage_->CreateResponseWriter(manifest_url_,
                                                 group_->group_id());
   stored_response_ids_.push_back(writer->response_id());
   return writer;
 }
 
-void AppCacheUpdateJob::HandleCacheFailure(const ErrorDetails& error_details,
-                                           ResultType result,
-                                           const GURL& failed_resource_url) {
+void AppCacheUpdateJob::HandleCacheFailure(
+    const AppCacheErrorDetails& error_details,
+    ResultType result,
+    const GURL& failed_resource_url) {
   // 6.9.4 cache failure steps 2-8.
   DCHECK(internal_state_ != CACHE_FAILURE);
   DCHECK(!error_details.message.empty());
   DCHECK(result != UPDATE_OK);
   internal_state_ = CACHE_FAILURE;
   LogHistogramStats(result, failed_resource_url);
   CancelAllUrlFetches();
   CancelAllMasterEntryFetches(error_details);
   NotifyAllError(error_details);
   DiscardInprogressCache();
@@ skipping 58 matching lines @@
       ContinueHandleManifestFetchCompleted(true);
   } else if (response_code == 304 && update_type_ == UPGRADE_ATTEMPT) {
     ContinueHandleManifestFetchCompleted(false);
   } else if ((response_code == 404 || response_code == 410) &&
              update_type_ == UPGRADE_ATTEMPT) {
     storage_->MakeGroupObsolete(group_, this, response_code);  // async
   } else {
     const char* kFormatString = "Manifest fetch failed (%d) %s";
     std::string message = FormatUrlErrorMessage(
         kFormatString, manifest_url_, fetcher->result(), response_code);
-    HandleCacheFailure(ErrorDetails(message,
+    HandleCacheFailure(AppCacheErrorDetails(message,
                                     appcache::MANIFEST_ERROR,
                                     manifest_url_,
                                     response_code,
                                     false /*is_cross_origin*/),
                        fetcher->result(),
                        GURL());
   }
 }
 
 void AppCacheUpdateJob::OnGroupMadeObsolete(AppCacheGroup* group,
                                             bool success,
                                             int response_code) {
   DCHECK(master_entry_fetches_.empty());
-  CancelAllMasterEntryFetches(ErrorDetails(
+  CancelAllMasterEntryFetches(AppCacheErrorDetails(
       "The cache has been made obsolete, "
       "the manifest file returned 404 or 410",
       appcache::MANIFEST_ERROR,
       GURL(),
       response_code,
       false /*is_cross_origin*/));
   if (success) {
     DCHECK(group->is_obsolete());
     NotifyAllAssociatedHosts(OBSOLETE_EVENT);
     internal_state_ = COMPLETED;
     MaybeCompleteUpdate();
   } else {
     // Treat failure to mark group obsolete as a cache failure.
-    HandleCacheFailure(ErrorDetails("Failed to mark the cache as obsolete",
-                                    UNKNOWN_ERROR,
-                                    GURL(),
-                                    0,
-                                    false /*is_cross_origin*/),
+    HandleCacheFailure(AppCacheErrorDetails(
+        "Failed to mark the cache as obsolete",
+        UNKNOWN_ERROR,
+        GURL(),
+        0,
+        false /*is_cross_origin*/),
                        DB_ERROR,
                        GURL());
   }
 }
 
 void AppCacheUpdateJob::ContinueHandleManifestFetchCompleted(bool changed) {
   DCHECK(internal_state_ == FETCH_MANIFEST);
 
   if (!changed) {
     DCHECK(update_type_ == UPGRADE_ATTEMPT);
     internal_state_ = NO_UPDATE;
 
     // Wait for pending master entries to download.
     FetchMasterEntries();
     MaybeCompleteUpdate();  // if not done, run async 6.9.4 step 7 substeps
     return;
   }
 
   Manifest manifest;
   if (!ParseManifest(manifest_url_, manifest_data_.data(),
                      manifest_data_.length(),
                      manifest_has_valid_mime_type_ ?
                         PARSE_MANIFEST_ALLOWING_INTERCEPTS :
                         PARSE_MANIFEST_PER_STANDARD,
                      manifest)) {
     const char* kFormatString = "Failed to parse manifest %s";
     const std::string message = base::StringPrintf(kFormatString,
         manifest_url_.spec().c_str());
     HandleCacheFailure(
-        ErrorDetails(
+        AppCacheErrorDetails(
             message, SIGNATURE_ERROR, GURL(), 0, false /*is_cross_origin*/),
         MANIFEST_ERROR,
         GURL());
     VLOG(1) << message;
     return;
   }
 
   // Proceed with update process. Section 6.9.4 steps 8-20.
   internal_state_ = DOWNLOADING;
   inprogress_cache_ = new AppCache(storage_, storage_->NewCacheId());
@@ skipping 12 matching lines @@
   }
 
   if (manifest.did_ignore_intercept_namespaces) {
     // Must be done after associating all pending master hosts.
     std::string message(
         "Ignoring the INTERCEPT section of the application cache manifest "
         "because the content type is not text/cache-manifest");
     LogConsoleMessageToAll(message);
   }
 
-  group_->SetUpdateStatus(AppCacheGroup::DOWNLOADING);
+  group_->SetUpdateAppCacheStatus(AppCacheGroup::DOWNLOADING);
   NotifyAllAssociatedHosts(DOWNLOADING_EVENT);
   FetchUrls();
   FetchMasterEntries();
   MaybeCompleteUpdate();  // if not done, continues when async fetches complete
 }
 
 void AppCacheUpdateJob::HandleUrlFetchCompleted(URLFetcher* fetcher) {
   DCHECK(internal_state_ == DOWNLOADING);
 
   net::URLRequest* request = fetcher->request();
@@ skipping 38 matching lines @@
         inprogress_cache_->AddOrModifyEntry(url, entry);
       } else {
         const char* kFormatString = "Resource fetch failed (%d) %s";
         std::string message = FormatUrlErrorMessage(
             kFormatString, url, fetcher->result(), response_code);
         ResultType result = fetcher->result();
         bool is_cross_origin = url.GetOrigin() != manifest_url_.GetOrigin();
         switch (result) {
           case DISKCACHE_ERROR:
             HandleCacheFailure(
-                ErrorDetails(
+                AppCacheErrorDetails(
                     message, UNKNOWN_ERROR, GURL(), 0, is_cross_origin),
                 result,
                 url);
             break;
           case NETWORK_ERROR:
             HandleCacheFailure(
-                ErrorDetails(message, RESOURCE_ERROR, url, 0, is_cross_origin),
+                AppCacheErrorDetails(message, RESOURCE_ERROR, url, 0,
+                    is_cross_origin),
                 result,
                 url);
             break;
           default:
-            HandleCacheFailure(ErrorDetails(message,
+            HandleCacheFailure(AppCacheErrorDetails(message,
                                             RESOURCE_ERROR,
                                             url,
                                             response_code,
                                             is_cross_origin),
                                result,
                                url);
             break;
         }
         return;
       }
@@ skipping 73 matching lines @@
         host->AssociateNoCache(GURL());
 
       host->RemoveObserver(this);
     }
     hosts.clear();
 
     const char* kFormatString = "Manifest fetch failed (%d) %s";
     std::string message = FormatUrlErrorMessage(
         kFormatString, request->url(), fetcher->result(), response_code);
     host_notifier.SendErrorNotifications(
-        ErrorDetails(message,
+        AppCacheErrorDetails(message,
                      appcache::MANIFEST_ERROR,
                      request->url(),
                      response_code,
                      false /*is_cross_origin*/));
 
     // In downloading case, update result is different if all master entries
     // failed vs. only some failing.
     if (inprogress_cache_.get()) {
       // Only count successful downloads to know if all master entries failed.
       pending_master_entries_.erase(found);
       --master_entries_completed_;
 
       // Section 6.9.4, step 22.3.
       if (update_type_ == CACHE_ATTEMPT && pending_master_entries_.empty()) {
-        HandleCacheFailure(ErrorDetails(message,
+        HandleCacheFailure(AppCacheErrorDetails(message,
                                         appcache::MANIFEST_ERROR,
                                         request->url(),
                                         response_code,
                                         false /*is_cross_origin*/),
                            fetcher->result(),
                            GURL());
         return;
       }
     }
   }
@@ skipping 27 matching lines @@
           io_buffer.get(),
           base::Bind(&AppCacheUpdateJob::OnManifestInfoWriteComplete,
                      base::Unretained(this)));
     }
   } else {
     VLOG(1) << "Request status: " << request->status().status()
             << " error: " << request->status().error()
             << " response code: " << response_code;
     ScheduleUpdateRetry(kRerunDelayMs);
     if (response_code == 200) {
-      HandleCacheFailure(ErrorDetails("Manifest changed during update",
+      HandleCacheFailure(AppCacheErrorDetails("Manifest changed during update",
                                       CHANGED_ERROR,
                                       GURL(),
                                       0,
                                       false /*is_cross_origin*/),
                          MANIFEST_ERROR,
                          GURL());
     } else {
       const char* kFormatString = "Manifest re-fetch failed (%d) %s";
       std::string message = FormatUrlErrorMessage(
           kFormatString, manifest_url_, fetcher->result(), response_code);
-      HandleCacheFailure(ErrorDetails(message,
+      HandleCacheFailure(AppCacheErrorDetails(message,
                                       appcache::MANIFEST_ERROR,
                                       GURL(),
                                       response_code,
                                       false /*is_cross_origin*/),
                          fetcher->result(),
                          GURL());
     }
   }
 }
 
 void AppCacheUpdateJob::OnManifestInfoWriteComplete(int result) {
   if (result > 0) {
     scoped_refptr<net::StringIOBuffer> io_buffer(
         new net::StringIOBuffer(manifest_data_));
     manifest_response_writer_->WriteData(
         io_buffer.get(),
         manifest_data_.length(),
         base::Bind(&AppCacheUpdateJob::OnManifestDataWriteComplete,
                    base::Unretained(this)));
   } else {
     HandleCacheFailure(
-        ErrorDetails("Failed to write the manifest headers to storage",
+        AppCacheErrorDetails("Failed to write the manifest headers to storage",
                      UNKNOWN_ERROR,
                      GURL(),
                      0,
                      false /*is_cross_origin*/),
         DISKCACHE_ERROR,
         GURL());
   }
 }
 
 void AppCacheUpdateJob::OnManifestDataWriteComplete(int result) {
   if (result > 0) {
     AppCacheEntry entry(AppCacheEntry::MANIFEST,
         manifest_response_writer_->response_id(),
         manifest_response_writer_->amount_written());
     if (!inprogress_cache_->AddOrModifyEntry(manifest_url_, entry))
       duplicate_response_ids_.push_back(entry.response_id());
     StoreGroupAndCache();
   } else {
     HandleCacheFailure(
-        ErrorDetails("Failed to write the manifest data to storage",
+        AppCacheErrorDetails("Failed to write the manifest data to storage",
                      UNKNOWN_ERROR,
                      GURL(),
                      0,
                      false /*is_cross_origin*/),
         DISKCACHE_ERROR,
         GURL());
   }
 }
 
 void AppCacheUpdateJob::StoreGroupAndCache() {
@@ skipping 21 matching lines @@
     MaybeCompleteUpdate();  // will definitely complete
   } else {
     stored_state_ = UNSTORED;
 
     // Restore inprogress_cache_ to get the proper events delivered
     // and the proper cleanup to occur.
     if (newest_cache != group->newest_complete_cache())
       inprogress_cache_ = newest_cache;
 
     ResultType result = DB_ERROR;
-    ErrorReason reason = UNKNOWN_ERROR;
+    AppCacheErrorReason reason = UNKNOWN_ERROR;
     std::string message("Failed to commit new cache to storage");
     if (would_exceed_quota) {
       message.append(", would exceed quota");
       result = QUOTA_ERROR;
       reason = appcache::QUOTA_ERROR;
     }
     HandleCacheFailure(
-        ErrorDetails(message, reason, GURL(), 0, false /*is_cross_origin*/),
+        AppCacheErrorDetails(message, reason, GURL(), 0,
+            false /*is_cross_origin*/),
         result,
         GURL());
   }
 }
 
 void AppCacheUpdateJob::NotifySingleHost(AppCacheHost* host,
-                                         EventID event_id) {
+                                         AppCacheEventID event_id) {
   std::vector<int> ids(1, host->host_id());
   host->frontend()->OnEventRaised(ids, event_id);
 }
 
-void AppCacheUpdateJob::NotifyAllAssociatedHosts(EventID event_id) {
+void AppCacheUpdateJob::NotifyAllAssociatedHosts(AppCacheEventID event_id) {
   HostNotifier host_notifier;
   AddAllAssociatedHostsToNotifier(&host_notifier);
   host_notifier.SendNotifications(event_id);
 }
 
 void AppCacheUpdateJob::NotifyAllProgress(const GURL& url) {
   HostNotifier host_notifier;
   AddAllAssociatedHostsToNotifier(&host_notifier);
   host_notifier.SendProgressNotifications(
       url, url_file_list_.size(), url_fetches_completed_);
 }
 
 void AppCacheUpdateJob::NotifyAllFinalProgress() {
   DCHECK(url_file_list_.size() == url_fetches_completed_);
   NotifyAllProgress(GURL());
 }
 
-void AppCacheUpdateJob::NotifyAllError(const ErrorDetails& details) {
+void AppCacheUpdateJob::NotifyAllError(const AppCacheErrorDetails& details) {
   HostNotifier host_notifier;
   AddAllAssociatedHostsToNotifier(&host_notifier);
   host_notifier.SendErrorNotifications(details);
 }
 
 void AppCacheUpdateJob::LogConsoleMessageToAll(const std::string& message) {
   HostNotifier host_notifier;
   AddAllAssociatedHostsToNotifier(&host_notifier);
   host_notifier.SendLogMessage(message);
 }
@@ skipping 43 matching lines @@
   AppCacheEntry* entry = NULL;
   if (group_->newest_complete_cache())
     entry = group_->newest_complete_cache()->GetEntry(manifest_url_);
   if (!entry) {
     // TODO(michaeln): This is just a bandaid to avoid a crash.
     // http://code.google.com/p/chromium/issues/detail?id=95101
     if (service_->storage() == storage_) {
       // Use a local variable because service_ is reset in HandleCacheFailure.
       AppCacheServiceImpl* service = service_;
       HandleCacheFailure(
-          ErrorDetails("Manifest entry not found in existing cache",
+          AppCacheErrorDetails("Manifest entry not found in existing cache",
                        UNKNOWN_ERROR,
                        GURL(),
                        0,
                        false /*is_cross_origin*/),
           DB_ERROR,
           GURL());
       AppCacheHistograms::AddMissingManifestEntrySample();
       service->DeleteAppCacheGroup(manifest_url_, net::CompletionCallback());
     }
     return;
@@ skipping 226 matching lines @@
           url, URLFetcher::MASTER_ENTRY_FETCH, this);
       fetcher->Start();
       master_entry_fetches_.insert(PendingUrlFetches::value_type(url, fetcher));
     }
 
     master_entries_to_fetch_.erase(master_entries_to_fetch_.begin());
   }
 }
 
 void AppCacheUpdateJob::CancelAllMasterEntryFetches(
-    const ErrorDetails& error_details) {
+    const AppCacheErrorDetails& error_details) {
   // For now, cancel all in-progress fetches for master entries and pretend
   // all master entries fetches have completed.
   // TODO(jennb): Delete this when update no longer fetches master entries
   // directly.
 
   // Cancel all in-progress fetches.
   for (PendingUrlFetches::iterator it = master_entry_fetches_.begin();
        it != master_entry_fetches_.end(); ++it) {
     delete it->second;
     master_entries_to_fetch_.insert(it->first);  // back in unfetched list
@@ skipping 284 matching lines @@
 
 void AppCacheUpdateJob::DeleteSoon() {
   ClearPendingMasterEntries();
   manifest_response_writer_.reset();
   storage_->CancelDelegateCallbacks(this);
   service_->RemoveObserver(this);
   service_ = NULL;
 
   // 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_->SetUpdateAppCacheStatus(AppCacheGroup::IDLE);
   group_ = NULL;
 
   base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
 }  // namespace appcache