Rename appcache constants in preparation for move to content namespace

BUG=338338
TBR=darin@chromium.org

Review URL: https://codereview.chromium.org/337713004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@277339 0039d316-1c4b-4281-b951-d872f2087c98

14 files changed, 86 insertions, 82 deletions

diff --git a/webkit/browser/appcache/appcache.cc b/webkit/browser/appcache/appcache.cc
index 2014298..9179a40 100644
--- a/webkit/browser/appcache/appcache.cc
+++ b/webkit/browser/appcache/appcache.cc
@@ -181,7 +181,7 @@ void AppCache::InitializeWithDatabaseRecords(
   for (size_t i = 0; i < whitelists.size(); ++i) {
     const AppCacheDatabase::OnlineWhiteListRecord& record = whitelists.at(i);
     online_whitelist_namespaces_.push_back(
-        Namespace(NETWORK_NAMESPACE,
+        Namespace(APPCACHE_NETWORK_NAMESPACE,
                   record.namespace_url,
                   GURL(),
                   record.is_pattern));
diff --git a/webkit/browser/appcache/appcache_database.cc b/webkit/browser/appcache/appcache_database.cc
index c000451..a5349d8 100644
--- a/webkit/browser/appcache/appcache_database.cc
+++ b/webkit/browser/appcache/appcache_database.cc
@@ -954,7 +954,7 @@ void AppCacheDatabase::ReadNamespaceRecords(
     AppCacheNamespaceType type = static_cast<AppCacheNamespaceType>(
         statement->ColumnInt(2));
     NamespaceRecordVector* records =
-        (type == FALLBACK_NAMESPACE) ? fallbacks : intercepts;
+        (type == APPCACHE_FALLBACK_NAMESPACE) ? fallbacks : intercepts;
     records->push_back(NamespaceRecord());
     ReadNamespaceRecord(statement, &records->back());
   }
@@ -1129,8 +1129,9 @@ bool AppCacheDatabase::UpgradeSchema() {
     }
 
     // Move data from the old table to the new table, setting the
-    // 'type' for all current records to the value for FALLBACK_NAMESPACE.
-    DCHECK_EQ(0, static_cast<int>(FALLBACK_NAMESPACE));
+    // 'type' for all current records to the value for
+    // APPCACHE_FALLBACK_NAMESPACE.
+    DCHECK_EQ(0, static_cast<int>(APPCACHE_FALLBACK_NAMESPACE));
     if (!db_->Execute(
             "INSERT INTO Namespaces"
             "  SELECT cache_id, origin, 0, namespace_url, fallback_entry_url"
diff --git a/webkit/browser/appcache/appcache_entry.h b/webkit/browser/appcache/appcache_entry.h
index 01b5f6c..fabaa62 100644
--- a/webkit/browser/appcache/appcache_entry.h
+++ b/webkit/browser/appcache/appcache_entry.h
@@ -28,10 +28,10 @@ class AppCacheEntry {
   };
 
   AppCacheEntry()
-    : types_(0), response_id_(kNoResponseId), response_size_(0) {}
+    : types_(0), response_id_(kAppCacheNoResponseId), response_size_(0) {}
 
   explicit AppCacheEntry(int type)
-    : types_(type), response_id_(kNoResponseId), response_size_(0) {}
+    : types_(type), response_id_(kAppCacheNoResponseId), response_size_(0) {}
 
   AppCacheEntry(int type, int64 response_id)
     : types_(type), response_id_(response_id), response_size_(0) {}
@@ -51,7 +51,7 @@ class AppCacheEntry {
 
   int64 response_id() const { return response_id_; }
   void set_response_id(int64 id) { response_id_ = id; }
-  bool has_response_id() const { return response_id_ != kNoResponseId; }
+  bool has_response_id() const { return response_id_ != kAppCacheNoResponseId; }
 
   int64 response_size() const { return response_size_; }
   void set_response_size(int64 size) { response_size_ = size; }
diff --git a/webkit/browser/appcache/appcache_host.cc b/webkit/browser/appcache/appcache_host.cc
index bcd9c7d..b656b06 100644
--- a/webkit/browser/appcache/appcache_host.cc
+++ b/webkit/browser/appcache/appcache_host.cc
@@ -45,10 +45,10 @@ void FillCacheInfo(const AppCache* cache,
 AppCacheHost::AppCacheHost(int host_id, AppCacheFrontend* frontend,
                            AppCacheServiceImpl* service)
     : host_id_(host_id),
-      spawning_host_id_(kNoHostId), spawning_process_id_(0),
-      parent_host_id_(kNoHostId), parent_process_id_(0),
-      pending_main_resource_cache_id_(kNoCacheId),
-      pending_selected_cache_id_(kNoCacheId),
+      spawning_host_id_(kAppCacheNoHostId), spawning_process_id_(0),
+      parent_host_id_(kAppCacheNoHostId), parent_process_id_(0),
+      pending_main_resource_cache_id_(kAppCacheNoCacheId),
+      pending_selected_cache_id_(kAppCacheNoCacheId),
       frontend_(frontend), service_(service),
       storage_(service->storage()),
       pending_callback_param_(NULL),
@@ -101,7 +101,7 @@ void AppCacheHost::SelectCache(const GURL& document_url,
   // MarkAsForeignEntry is called in that case, so that detection
   // step is skipped here. See WebApplicationCacheHostImpl.cc
 
-  if (cache_document_was_loaded_from != kNoCacheId) {
+  if (cache_document_was_loaded_from != kAppCacheNoCacheId) {
     LoadSelectedCache(cache_document_was_loaded_from);
     return;
   }
@@ -114,12 +114,12 @@ void AppCacheHost::SelectCache(const GURL& document_url,
         !policy->CanCreateAppCache(manifest_url, first_party_url_)) {
       FinishCacheSelection(NULL, NULL);
       std::vector<int> host_ids(1, host_id_);
-      frontend_->OnEventRaised(host_ids, CHECKING_EVENT);
+      frontend_->OnEventRaised(host_ids, APPCACHE_CHECKING_EVENT);
       frontend_->OnErrorEventRaised(
           host_ids,
           AppCacheErrorDetails(
               "Cache creation was blocked by the content policy",
-              POLICY_ERROR,
+              APPCACHE_POLICY_ERROR,
               GURL(),
               0,
               false /*is_cross_origin*/));
@@ -159,7 +159,7 @@ void AppCacheHost::SelectCacheForSharedWorker(int64 appcache_id) {
          pending_get_status_callback_.is_null() &&
          !is_selection_pending());
 
-  if (appcache_id != kNoCacheId) {
+  if (appcache_id != kAppCacheNoCacheId) {
     LoadSelectedCache(appcache_id);
     return;
   }
@@ -173,7 +173,7 @@ void AppCacheHost::MarkAsForeignEntry(const GURL& document_url,
   storage()->MarkEntryAsForeign(
       main_resource_was_namespace_entry_ ? namespace_entry_url_ : document_url,
       cache_document_was_loaded_from);
-  SelectCache(document_url, kNoCacheId, GURL());
+  SelectCache(document_url, kAppCacheNoCacheId, GURL());
 }
 
 void AppCacheHost::GetStatusWithCallback(const GetStatusCallback& callback,
@@ -317,22 +317,22 @@ AppCacheStatus AppCacheHost::GetStatus() {
   // 6.9.8 Application cache API
   AppCache* cache = associated_cache();
   if (!cache)
-    return UNCACHED;
+    return APPCACHE_STATUS_UNCACHED;
 
   // A cache without an owning group represents the cache being constructed
   // during the application cache update process.
   if (!cache->owning_group())
-    return DOWNLOADING;
+    return APPCACHE_STATUS_DOWNLOADING;
 
   if (cache->owning_group()->is_obsolete())
-    return OBSOLETE;
+    return APPCACHE_STATUS_OBSOLETE;
   if (cache->owning_group()->update_status() == AppCacheGroup::CHECKING)
-    return CHECKING;
+    return APPCACHE_STATUS_CHECKING;
   if (cache->owning_group()->update_status() == AppCacheGroup::DOWNLOADING)
-    return DOWNLOADING;
+    return APPCACHE_STATUS_DOWNLOADING;
   if (swappable_cache_.get())
-    return UPDATE_READY;
-  return IDLE;
+    return APPCACHE_STATUS_UPDATE_READY;
+  return APPCACHE_STATUS_IDLE;
 }
 
 void AppCacheHost::LoadOrCreateGroup(const GURL& manifest_url) {
@@ -349,17 +349,17 @@ void AppCacheHost::OnGroupLoaded(AppCacheGroup* group,
 }
 
 void AppCacheHost::LoadSelectedCache(int64 cache_id) {
-  DCHECK(cache_id != kNoCacheId);
+  DCHECK(cache_id != kAppCacheNoCacheId);
   pending_selected_cache_id_ = cache_id;
   storage()->LoadCache(cache_id, this);
 }
 
 void AppCacheHost::OnCacheLoaded(AppCache* cache, int64 cache_id) {
   if (cache_id == pending_main_resource_cache_id_) {
-    pending_main_resource_cache_id_ = kNoCacheId;
+    pending_main_resource_cache_id_ = kAppCacheNoCacheId;
     main_resource_cache_ = cache;
   } else if (cache_id == pending_selected_cache_id_) {
-    pending_selected_cache_id_ = kNoCacheId;
+    pending_selected_cache_id_ = kAppCacheNoCacheId;
     FinishCacheSelection(cache, NULL);
   }
 }
@@ -381,7 +381,7 @@ void AppCacheHost::FinishCacheSelection(
     const char* kFormatString =
         "Document was loaded from Application Cache with manifest %s";
     frontend_->OnLogMessage(
-        host_id_, LOG_INFO,
+        host_id_, APPCACHE_LOG_INFO,
         base::StringPrintf(
             kFormatString, owing_group->manifest_url().spec().c_str()));
     AssociateCompleteCache(cache);
@@ -402,7 +402,7 @@ void AppCacheHost::FinishCacheSelection(
         "Adding master entry to Application Cache with manifest %s" :
         "Creating Application Cache with manifest %s";
     frontend_->OnLogMessage(
-        host_id_, LOG_INFO,
+        host_id_, APPCACHE_LOG_INFO,
         base::StringPrintf(kFormatString,
                            group->manifest_url().spec().c_str()));
     // The UpdateJob may produce one for us later.
@@ -474,7 +474,7 @@ void AppCacheHost::SetSwappableCache(AppCacheGroup* group) {
 }
 
 void AppCacheHost::LoadMainResourceCache(int64 cache_id) {
-  DCHECK(cache_id != kNoCacheId);
+  DCHECK(cache_id != kAppCacheNoCacheId);
   if (pending_main_resource_cache_id_ == cache_id ||
       (main_resource_cache_.get() &&
        main_resource_cache_->cache_id() == cache_id)) {
@@ -500,7 +500,7 @@ void AppCacheHost::PrepareForTransfer() {
   DCHECK(!associated_cache());
   DCHECK(!is_selection_pending());
   DCHECK(!group_being_updated_);
-  host_id_ = kNoHostId;
+  host_id_ = kAppCacheNoHostId;
   frontend_ = NULL;
 }
 
diff --git a/webkit/browser/appcache/appcache_host.h b/webkit/browser/appcache/appcache_host.h
index 8ce8141..0831f15 100644
--- a/webkit/browser/appcache/appcache_host.h
+++ b/webkit/browser/appcache/appcache_host.h
@@ -167,7 +167,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT AppCacheHost
   AppCache* associated_cache() const { return associated_cache_.get(); }
 
   bool is_selection_pending() const {
-    return pending_selected_cache_id_ != kNoCacheId ||
+    return pending_selected_cache_id_ != kAppCacheNoCacheId ||
            !pending_selected_manifest_url_.is_empty();
   }
 
@@ -210,7 +210,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT AppCacheHost
 
   // Returns true if this host is for a dedicated worker context.
   bool is_for_dedicated_worker() const {
-    return parent_host_id_ != kNoHostId;
+    return parent_host_id_ != kAppCacheNoHostId;
   }
 
   // Returns the parent context's host instance. This is only valid
diff --git a/webkit/browser/appcache/appcache_request_handler.cc b/webkit/browser/appcache/appcache_request_handler.cc
index 483f8c3..0777044 100644
--- a/webkit/browser/appcache/appcache_request_handler.cc
+++ b/webkit/browser/appcache/appcache_request_handler.cc
@@ -62,7 +62,7 @@ AppCacheURLRequestJob* AppCacheRequestHandler::MaybeLoadResource(
   // new resource, any values in those fields are no longer valid.
   found_entry_ = AppCacheEntry();
   found_fallback_entry_ = AppCacheEntry();
-  found_cache_id_ = kNoCacheId;
+  found_cache_id_ = kAppCacheNoCacheId;
   found_manifest_url_ = GURL();
   found_network_namespace_ = false;
 
@@ -274,7 +274,7 @@ void AppCacheRequestHandler::OnMainResponseFound(
     return;
   }
 
-  if (ResourceType::IsFrame(resource_type_) && cache_id != kNoCacheId) {
+  if (ResourceType::IsFrame(resource_type_) && cache_id != kAppCacheNoCacheId) {
     // AppCacheHost loads and holds a reference to the main resource cache
     // for two reasons, firstly to preload the cache into the working set
     // in advance of subresource loads happening, secondly to prevent the
diff --git a/webkit/browser/appcache/appcache_response.cc b/webkit/browser/appcache/appcache_response.cc
index 9ba1dff..cd0d384 100644
--- a/webkit/browser/appcache/appcache_response.cc
+++ b/webkit/browser/appcache/appcache_response.cc
@@ -55,7 +55,7 @@ AppCacheResponseInfo::AppCacheResponseInfo(
       http_response_info_(http_info), response_data_size_(response_data_size),
       storage_(storage) {
   DCHECK(http_info);
-  DCHECK(response_id != kNoResponseId);
+  DCHECK(response_id != kAppCacheNoResponseId);
   storage_->working_set()->AddResponseInfo(this);
 }
 
diff --git a/webkit/browser/appcache/appcache_storage.h b/webkit/browser/appcache/appcache_storage.h
index a2c66eb..41bbd55 100644
--- a/webkit/browser/appcache/appcache_storage.h
+++ b/webkit/browser/appcache/appcache_storage.h
@@ -69,7 +69,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT AppCacheStorage {
         AppCacheResponseInfo* response_info, int64 response_id) {}
 
     // If no response is found, entry.response_id() and
-    // fallback_entry.response_id() will be kNoResponseId.
+    // fallback_entry.response_id() will be kAppCacheNoResponseId.
     // If the response is the entry for an intercept or fallback
     // namespace, the url of the namespece entry is returned.
     // If a response is found, the cache id and manifest url of the
diff --git a/webkit/browser/appcache/appcache_storage_impl.cc b/webkit/browser/appcache/appcache_storage_impl.cc
index 96c0b67..62563d7 100644
--- a/webkit/browser/appcache/appcache_storage_impl.cc
+++ b/webkit/browser/appcache/appcache_storage_impl.cc
@@ -859,7 +859,7 @@ class NetworkNamespaceHelper {
     WhiteListVector::const_iterator iter = records.begin();
     while (iter != records.end()) {
       namespaces->push_back(
-            Namespace(NETWORK_NAMESPACE, iter->namespace_url, GURL(),
+            Namespace(APPCACHE_NETWORK_NAMESPACE, iter->namespace_url, GURL(),
                       iter->is_pattern));
       ++iter;
     }
@@ -881,7 +881,7 @@ class AppCacheStorageImpl::FindMainResponseTask : public DatabaseTask {
                        const AppCacheWorkingSet::GroupMap* groups_in_use)
       : DatabaseTask(storage), url_(url),
         preferred_manifest_url_(preferred_manifest_url),
-        cache_id_(kNoCacheId), group_id_(0) {
+        cache_id_(kAppCacheNoCacheId), group_id_(0) {
     if (groups_in_use) {
       for (AppCacheWorkingSet::GroupMap::const_iterator it =
                groups_in_use->begin();
@@ -938,7 +938,7 @@ void AppCacheStorageImpl::FindMainResponseTask::Run() {
   // TODO(michaeln): come up with a 'preferred_manifest_url' in more cases
   // - when navigating a frame whose current contents are from an appcache
   // - when clicking an href in a frame that is appcached
-  int64 preferred_cache_id = kNoCacheId;
+  int64 preferred_cache_id = kAppCacheNoCacheId;
   if (!preferred_manifest_url_.is_empty()) {
     AppCacheDatabase::GroupRecord preferred_group;
     AppCacheDatabase::CacheRecord preferred_cache;
@@ -953,13 +953,13 @@ void AppCacheStorageImpl::FindMainResponseTask::Run() {
   if (FindExactMatch(preferred_cache_id) ||
       FindNamespaceMatch(preferred_cache_id)) {
     // We found something.
-    DCHECK(cache_id_ != kNoCacheId && !manifest_url_.is_empty() &&
+    DCHECK(cache_id_ != kAppCacheNoCacheId && !manifest_url_.is_empty() &&
            group_id_ != 0);
     return;
   }
 
   // We didn't find anything.
-  DCHECK(cache_id_ == kNoCacheId && manifest_url_.is_empty() &&
+  DCHECK(cache_id_ == kAppCacheNoCacheId && manifest_url_.is_empty() &&
          group_id_ == 0);
 }
 
@@ -1071,7 +1071,7 @@ FindMainResponseTask::FindFirstValidNamespace(
       group_id_ = group_record.group_id;
       cache_id_ = (*iter)->cache_id;
       namespace_entry_url_ = (*iter)->namespace_.target_url;
-      if ((*iter)->namespace_.type == FALLBACK_NAMESPACE)
+      if ((*iter)->namespace_.type == APPCACHE_FALLBACK_NAMESPACE)
         fallback_entry_ = AppCacheEntry(entry_record.flags,
                                         entry_record.response_id);
       else
@@ -1559,8 +1559,8 @@ void AppCacheStorageImpl::DeliverShortCircuitedFindMainResponse(
     CallOnMainResponseFound(
         &delegates, url, found_entry,
         GURL(), AppCacheEntry(),
-        cache.get() ? cache->cache_id() : kNoCacheId,
-        group.get() ? group->group_id() : kNoCacheId,
+        cache.get() ? cache->cache_id() : kAppCacheNoCacheId,
+        group.get() ? group->group_id() : kAppCacheNoCacheId,
         group.get() ? group->manifest_url() : GURL());
   }
 }
diff --git a/webkit/browser/appcache/appcache_update_job.cc b/webkit/browser/appcache/appcache_update_job.cc
index 3266f5e..0c5593c 100644
--- a/webkit/browser/appcache/appcache_update_job.cc
+++ b/webkit/browser/appcache/appcache_update_job.cc
@@ -91,7 +91,7 @@ class HostNotifier {
       AppCacheFrontend* frontend = it->first;
       for (HostIds::iterator id = it->second.begin();
            id != it->second.end(); ++id) {
-        frontend->OnLogMessage(*id, LOG_WARNING, message);
+        frontend->OnLogMessage(*id, APPCACHE_LOG_WARNING, message);
       }
     }
   }
@@ -402,9 +402,9 @@ void AppCacheUpdateJob::StartUpdate(AppCacheHost* host,
   if (update_status == AppCacheGroup::CHECKING ||
       update_status == AppCacheGroup::DOWNLOADING) {
     if (host) {
-      NotifySingleHost(host, CHECKING_EVENT);
+      NotifySingleHost(host, APPCACHE_CHECKING_EVENT);
       if (update_status == AppCacheGroup::DOWNLOADING)
-        NotifySingleHost(host, DOWNLOADING_EVENT);
+        NotifySingleHost(host, APPCACHE_DOWNLOADING_EVENT);
 
       // Add to fetch list or an existing entry if already fetched.
       if (!new_master_resource.is_empty()) {
@@ -420,11 +420,11 @@ void AppCacheUpdateJob::StartUpdate(AppCacheHost* host,
   group_->SetUpdateAppCacheStatus(AppCacheGroup::CHECKING);
   if (group_->HasCache()) {
     update_type_ = UPGRADE_ATTEMPT;
-    NotifyAllAssociatedHosts(CHECKING_EVENT);
+    NotifyAllAssociatedHosts(APPCACHE_CHECKING_EVENT);
   } else {
     update_type_ = CACHE_ATTEMPT;
     DCHECK(host);
-    NotifySingleHost(host, CHECKING_EVENT);
+    NotifySingleHost(host, APPCACHE_CHECKING_EVENT);
   }
 
   if (!new_master_resource.is_empty()) {
@@ -526,7 +526,7 @@ void AppCacheUpdateJob::HandleManifestFetchCompleted(
     std::string message = FormatUrlErrorMessage(
         kFormatString, manifest_url_, fetcher->result(), response_code);
     HandleCacheFailure(AppCacheErrorDetails(message,
-                                    appcache::MANIFEST_ERROR,
+                                    appcache::APPCACHE_MANIFEST_ERROR,
                                     manifest_url_,
                                     response_code,
                                     false /*is_cross_origin*/),
@@ -542,20 +542,20 @@ void AppCacheUpdateJob::OnGroupMadeObsolete(AppCacheGroup* group,
   CancelAllMasterEntryFetches(AppCacheErrorDetails(
       "The cache has been made obsolete, "
       "the manifest file returned 404 or 410",
-      appcache::MANIFEST_ERROR,
+      appcache::APPCACHE_MANIFEST_ERROR,
       GURL(),
       response_code,
       false /*is_cross_origin*/));
   if (success) {
     DCHECK(group->is_obsolete());
-    NotifyAllAssociatedHosts(OBSOLETE_EVENT);
+    NotifyAllAssociatedHosts(APPCACHE_OBSOLETE_EVENT);
     internal_state_ = COMPLETED;
     MaybeCompleteUpdate();
   } else {
     // Treat failure to mark group obsolete as a cache failure.
     HandleCacheFailure(AppCacheErrorDetails(
         "Failed to mark the cache as obsolete",
-        UNKNOWN_ERROR,
+        APPCACHE_UNKNOWN_ERROR,
         GURL(),
         0,
         false /*is_cross_origin*/),
@@ -589,8 +589,9 @@ void AppCacheUpdateJob::ContinueHandleManifestFetchCompleted(bool changed) {
         manifest_url_.spec().c_str());
     HandleCacheFailure(
         AppCacheErrorDetails(
-            message, SIGNATURE_ERROR, GURL(), 0, false /*is_cross_origin*/),
-        MANIFEST_ERROR,
+            message, APPCACHE_SIGNATURE_ERROR, GURL(), 0,
+            false /*is_cross_origin*/),
+        APPCACHE_MANIFEST_ERROR,
         GURL());
     VLOG(1) << message;
     return;
@@ -622,7 +623,7 @@ void AppCacheUpdateJob::ContinueHandleManifestFetchCompleted(bool changed) {
   }
 
   group_->SetUpdateAppCacheStatus(AppCacheGroup::DOWNLOADING);
-  NotifyAllAssociatedHosts(DOWNLOADING_EVENT);
+  NotifyAllAssociatedHosts(APPCACHE_DOWNLOADING_EVENT);
   FetchUrls();
   FetchMasterEntries();
   MaybeCompleteUpdate();  // if not done, continues when async fetches complete
@@ -681,20 +682,21 @@ void AppCacheUpdateJob::HandleUrlFetchCompleted(URLFetcher* fetcher) {
           case DISKCACHE_ERROR:
             HandleCacheFailure(
                 AppCacheErrorDetails(
-                    message, UNKNOWN_ERROR, GURL(), 0, is_cross_origin),
+                    message, APPCACHE_UNKNOWN_ERROR, GURL(), 0,
+                    is_cross_origin),
                 result,
                 url);
             break;
           case NETWORK_ERROR:
             HandleCacheFailure(
-                AppCacheErrorDetails(message, RESOURCE_ERROR, url, 0,
+                AppCacheErrorDetails(message, APPCACHE_RESOURCE_ERROR, url, 0,
                     is_cross_origin),
                 result,
                 url);
             break;
           default:
             HandleCacheFailure(AppCacheErrorDetails(message,
-                                            RESOURCE_ERROR,
+                                            APPCACHE_RESOURCE_ERROR,
                                             url,
                                             response_code,
                                             is_cross_origin),
@@ -788,7 +790,7 @@ void AppCacheUpdateJob::HandleMasterEntryFetchCompleted(
         kFormatString, request->url(), fetcher->result(), response_code);
     host_notifier.SendErrorNotifications(
         AppCacheErrorDetails(message,
-                     appcache::MANIFEST_ERROR,
+                     appcache::APPCACHE_MANIFEST_ERROR,
                      request->url(),
                      response_code,
                      false /*is_cross_origin*/));
@@ -803,7 +805,7 @@ void AppCacheUpdateJob::HandleMasterEntryFetchCompleted(
       // Section 6.9.4, step 22.3.
       if (update_type_ == CACHE_ATTEMPT && pending_master_entries_.empty()) {
         HandleCacheFailure(AppCacheErrorDetails(message,
-                                        appcache::MANIFEST_ERROR,
+                                        appcache::APPCACHE_MANIFEST_ERROR,
                                         request->url(),
                                         response_code,
                                         false /*is_cross_origin*/),
@@ -851,18 +853,18 @@ void AppCacheUpdateJob::HandleManifestRefetchCompleted(
     ScheduleUpdateRetry(kRerunDelayMs);
     if (response_code == 200) {
       HandleCacheFailure(AppCacheErrorDetails("Manifest changed during update",
-                                      CHANGED_ERROR,
+                                      APPCACHE_CHANGED_ERROR,
                                       GURL(),
                                       0,
                                       false /*is_cross_origin*/),
-                         MANIFEST_ERROR,
+                         APPCACHE_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(AppCacheErrorDetails(message,
-                                      appcache::MANIFEST_ERROR,
+                                      appcache::APPCACHE_MANIFEST_ERROR,
                                       GURL(),
                                       response_code,
                                       false /*is_cross_origin*/),
@@ -884,7 +886,7 @@ void AppCacheUpdateJob::OnManifestInfoWriteComplete(int result) {
   } else {
     HandleCacheFailure(
         AppCacheErrorDetails("Failed to write the manifest headers to storage",
-                     UNKNOWN_ERROR,
+                     APPCACHE_UNKNOWN_ERROR,
                      GURL(),
                      0,
                      false /*is_cross_origin*/),
@@ -904,7 +906,7 @@ void AppCacheUpdateJob::OnManifestDataWriteComplete(int result) {
   } else {
     HandleCacheFailure(
         AppCacheErrorDetails("Failed to write the manifest data to storage",
-                     UNKNOWN_ERROR,
+                     APPCACHE_UNKNOWN_ERROR,
                      GURL(),
                      0,
                      false /*is_cross_origin*/),
@@ -945,12 +947,12 @@ void AppCacheUpdateJob::OnGroupAndNewestCacheStored(AppCacheGroup* group,
       inprogress_cache_ = newest_cache;
 
     ResultType result = DB_ERROR;
-    AppCacheErrorReason reason = UNKNOWN_ERROR;
+    AppCacheErrorReason reason = APPCACHE_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;
+      result = APPCACHE_QUOTA_ERROR;
+      reason = appcache::APPCACHE_QUOTA_ERROR;
     }
     HandleCacheFailure(
         AppCacheErrorDetails(message, reason, GURL(), 0,
@@ -1049,7 +1051,7 @@ void AppCacheUpdateJob::CheckIfManifestChanged() {
       AppCacheServiceImpl* service = service_;
       HandleCacheFailure(
           AppCacheErrorDetails("Manifest entry not found in existing cache",
-                       UNKNOWN_ERROR,
+                       APPCACHE_UNKNOWN_ERROR,
                        GURL(),
                        0,
                        false /*is_cross_origin*/),
@@ -1441,7 +1443,7 @@ void AppCacheUpdateJob::MaybeCompleteUpdate() {
         }
       }
       // 6.9.4 steps 7.3-7.7.
-      NotifyAllAssociatedHosts(NO_UPDATE_EVENT);
+      NotifyAllAssociatedHosts(APPCACHE_NO_UPDATE_EVENT);
       DiscardDuplicateResponses();
       internal_state_ = COMPLETED;
       break;
@@ -1453,9 +1455,9 @@ void AppCacheUpdateJob::MaybeCompleteUpdate() {
       DCHECK(stored_state_ == STORED);
       NotifyAllFinalProgress();
       if (update_type_ == CACHE_ATTEMPT)
-        NotifyAllAssociatedHosts(CACHED_EVENT);
+        NotifyAllAssociatedHosts(APPCACHE_CACHED_EVENT);
       else
-        NotifyAllAssociatedHosts(UPDATE_READY_EVENT);
+        NotifyAllAssociatedHosts(APPCACHE_UPDATE_READY_EVENT);
       DiscardDuplicateResponses();
       internal_state_ = COMPLETED;
       LogHistogramStats(UPDATE_OK, GURL());
diff --git a/webkit/browser/appcache/appcache_update_job.h b/webkit/browser/appcache/appcache_update_job.h
index 3384d9a..ba15541 100644
--- a/webkit/browser/appcache/appcache_update_job.h
+++ b/webkit/browser/appcache/appcache_update_job.h
@@ -44,8 +44,8 @@ class WEBKIT_STORAGE_BROWSER_EXPORT AppCacheUpdateJob
  public:
   // Used for uma stats only for now, so new values are append only.
   enum ResultType {
-    UPDATE_OK, DB_ERROR, DISKCACHE_ERROR, QUOTA_ERROR, REDIRECT_ERROR,
-    MANIFEST_ERROR, NETWORK_ERROR, SERVER_ERROR, CANCELLED_ERROR,
+    UPDATE_OK, DB_ERROR, DISKCACHE_ERROR, APPCACHE_QUOTA_ERROR, REDIRECT_ERROR,
+    APPCACHE_MANIFEST_ERROR, NETWORK_ERROR, SERVER_ERROR, CANCELLED_ERROR,
     NUM_UPDATE_JOB_RESULT_TYPES
   };
 
diff --git a/webkit/browser/appcache/appcache_url_request_job.cc b/webkit/browser/appcache/appcache_url_request_job.cc
index 088dafa..2cdcb77 100644
--- a/webkit/browser/appcache/appcache_url_request_job.cc
+++ b/webkit/browser/appcache/appcache_url_request_job.cc
@@ -40,7 +40,7 @@ AppCacheURLRequestJob::AppCacheURLRequestJob(
       storage_(storage),
       has_been_started_(false), has_been_killed_(false),
       delivery_type_(AWAITING_DELIVERY_ORDERS),
-      group_id_(0), cache_id_(kNoCacheId), is_fallback_(false),
+      group_id_(0), cache_id_(kAppCacheNoCacheId), is_fallback_(false),
       is_main_resource_(is_main_resource),
       cache_entry_not_found_(false),
       weak_factory_(this) {
@@ -256,7 +256,8 @@ void AppCacheURLRequestJob::OnExecutableResponseCallback(
 
 void AppCacheURLRequestJob::BeginErrorDelivery(const char* message) {
   if (host_)
-    host_->frontend()->OnLogMessage(host_->host_id(), LOG_ERROR, message);
+    host_->frontend()->OnLogMessage(host_->host_id(), APPCACHE_LOG_ERROR,
+                                    message);
   delivery_type_ = ERROR_DELIVERY;
   storage_ = NULL;
   BeginDelivery();
diff --git a/webkit/browser/appcache/appcache_working_set.cc b/webkit/browser/appcache/appcache_working_set.cc
index ea05110..2b9a70c 100644
--- a/webkit/browser/appcache/appcache_working_set.cc
+++ b/webkit/browser/appcache/appcache_working_set.cc
@@ -32,7 +32,7 @@ void AppCacheWorkingSet::Disable() {
 void AppCacheWorkingSet::AddCache(AppCache* cache) {
   if (is_disabled_)
     return;
-  DCHECK(cache->cache_id() != kNoCacheId);
+  DCHECK(cache->cache_id() != kAppCacheNoCacheId);
   int64 cache_id = cache->cache_id();
   DCHECK(caches_.find(cache_id) == caches_.end());
   caches_.insert(CacheMap::value_type(cache_id, cache));
@@ -67,7 +67,7 @@ void AppCacheWorkingSet::RemoveGroup(AppCacheGroup* group) {
 void AppCacheWorkingSet::AddResponseInfo(AppCacheResponseInfo* info) {
   if (is_disabled_)
     return;
-  DCHECK(info->response_id() != kNoResponseId);
+  DCHECK(info->response_id() != kAppCacheNoResponseId);
   int64 response_id = info->response_id();
   DCHECK(response_infos_.find(response_id) == response_infos_.end());
   response_infos_.insert(ResponseInfoMap::value_type(response_id, info));
diff --git a/webkit/browser/appcache/manifest_parser.cc b/webkit/browser/appcache/manifest_parser.cc
index 43ecd55..f43d889 100644
--- a/webkit/browser/appcache/manifest_parser.cc
+++ b/webkit/browser/appcache/manifest_parser.cc
@@ -219,7 +219,7 @@ bool ParseManifest(const GURL& manifest_url, const char* data, int length,
       } else {
         bool is_pattern = HasPatternMatchingAnnotation(line_p, line_end);
         manifest.online_whitelist_namespaces.push_back(
-            Namespace(NETWORK_NAMESPACE, url, GURL(), is_pattern));
+            Namespace(APPCACHE_NETWORK_NAMESPACE, url, GURL(), is_pattern));
       }
     } else if (mode == INTERCEPT) {
       if (parse_mode != PARSE_MANIFEST_ALLOWING_INTERCEPTS) {
@@ -304,7 +304,7 @@ bool ParseManifest(const GURL& manifest_url, const char* data, int length,
 
       bool is_pattern = HasPatternMatchingAnnotation(line_p, line_end);
       manifest.intercept_namespaces.push_back(
-          Namespace(INTERCEPT_NAMESPACE, namespace_url,
+          Namespace(APPCACHE_INTERCEPT_NAMESPACE, namespace_url,
                     target_url, is_pattern, verb == EXECUTE));
     } else if (mode == FALLBACK) {
       const wchar_t* line_p = line.c_str();
@@ -368,7 +368,7 @@ bool ParseManifest(const GURL& manifest_url, const char* data, int length,
       // Store regardless of duplicate namespace URL. Only first match
       // will ever be used.
       manifest.fallback_namespaces.push_back(
-          Namespace(FALLBACK_NAMESPACE, namespace_url,
+          Namespace(APPCACHE_FALLBACK_NAMESPACE, namespace_url,
                     fallback_url, is_pattern));
     } else {
       NOTREACHED();