Rename some appcache types in preparation for moving to content namespace

webkit/browser/appcache/appcache_database.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_database.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
@@ skipping 933 matching lines @@
   record->flags = statement.ColumnInt(2);
   record->response_id = statement.ColumnInt64(3);
   record->response_size = statement.ColumnInt64(4);
 }
 
 void AppCacheDatabase::ReadNamespaceRecords(
       sql::Statement* statement,
       NamespaceRecordVector* intercepts,
       NamespaceRecordVector* fallbacks) {
   while (statement->Step()) {
-    NamespaceType type = static_cast<NamespaceType>(statement->ColumnInt(2));
+    AppCacheNamespaceType type = static_cast<AppCacheNamespaceType>(
+        statement->ColumnInt(2));
     NamespaceRecordVector* records =
         (type == FALLBACK_NAMESPACE) ? fallbacks : intercepts;
     records->push_back(NamespaceRecord());
     ReadNamespaceRecord(statement, &records->back());
   }
 }
 
 void AppCacheDatabase::ReadNamespaceRecord(
     const sql::Statement* statement, NamespaceRecord* record) {
   record->cache_id = statement->ColumnInt64(0);
   record->origin = GURL(statement->ColumnString(1));
   int type_with_executable_bit = statement->ColumnInt(2);
   record->namespace_.namespace_url = GURL(statement->ColumnString(3));
   record->namespace_.target_url = GURL(statement->ColumnString(4));
   record->namespace_.is_pattern = statement->ColumnBool(5);
 
   // Note: quick and dirty storage for the 'executable' bit w/o changing
   // schemas, we use the high bit of 'type' field.
-  record->namespace_.type = static_cast<NamespaceType>
+  record->namespace_.type = static_cast<AppCacheNamespaceType>
       (type_with_executable_bit & 0x7ffffff);
   record->namespace_.is_executable =
       (type_with_executable_bit & 0x80000000) != 0;
   DCHECK(!record->namespace_.is_executable ||
       CommandLine::ForCurrentProcess()->HasSwitch(kEnableExecutableHandlers));
 }
 
 void AppCacheDatabase::ReadOnlineWhiteListRecord(
     const sql::Statement& statement, OnlineWhiteListRecord* record) {
   record->cache_id = statement.ColumnInt64(0);
@@ skipping 231 matching lines @@
 }
 
 void AppCacheDatabase::OnDatabaseError(int err, sql::Statement* stmt) {
   was_corruption_detected_ |= sql::IsErrorCatastrophic(err);
   if (!db_->ShouldIgnoreSqliteError(err))
     DLOG(ERROR) << db_->GetErrorMessage();
   // TODO: Maybe use non-catostrophic errors to trigger a full integrity check?
 }
 
 }  // namespace appcache