jumbo build: Rename constants to be unique (storage/browser)

When building using jumbo, files gets merged and
constants with the same name may end up in the same
namespace/scope and conflict.

This commit solves the issue by renaming the constants
to something more file specific.

Bug: 871163
Change-Id: Ic4973b976597dbc097897406951ae8c2cbdf6430
Reviewed-on: https://chromium-review.googlesource.com/1163505
Commit-Queue: Oscar Johansson <oscarj@opera.com>
Reviewed-by: Victor Costan <pwnall@chromium.org>
Cr-Commit-Position: refs/heads/master@{#581535}

storage/browser/database/database_quota_client.cc

@@ -62,8 +62,8 @@ void GetOriginsForHostOnDBThread(DatabaseTracker* db_tracker,
   }
 }
 
-void DidGetOrigins(QuotaClient::GetOriginsCallback callback,
-                   std::set<url::Origin>* origins_ptr) {
+void DidGetQuotaClientOrigins(QuotaClient::GetOriginsCallback callback,
+                              std::set<url::Origin>* origins_ptr) {
   std::move(callback).Run(*origins_ptr);
 }
 
@@ -145,7 +145,7 @@ void DatabaseQuotaClient::GetOriginsForType(StorageType type,
       FROM_HERE,
       base::BindOnce(&GetOriginsOnDBThread, base::RetainedRef(db_tracker_),
                      base::Unretained(origins_ptr)),
-      base::BindOnce(&DidGetOrigins, std::move(callback),
+      base::BindOnce(&DidGetQuotaClientOrigins, std::move(callback),
                      base::Owned(origins_ptr)));
 }
 
@@ -167,7 +167,7 @@ void DatabaseQuotaClient::GetOriginsForHost(StorageType type,
       base::BindOnce(&GetOriginsForHostOnDBThread,
                      base::RetainedRef(db_tracker_),
                      base::Unretained(origins_ptr), host),
-      base::BindOnce(&DidGetOrigins, std::move(callback),
+      base::BindOnce(&DidGetQuotaClientOrigins, std::move(callback),
                      base::Owned(origins_ptr)));
 }
 

storage/browser/database/database_tracker.cc

@@ -37,8 +37,8 @@ const base::FilePath::CharType kIncognitoDatabaseDirectoryName[] =
     FILE_PATH_LITERAL("databases-incognito");
 const base::FilePath::CharType kTrackerDatabaseFileName[] =
     FILE_PATH_LITERAL("Databases.db");
-static const int kCurrentVersion = 2;
-static const int kCompatibleVersion = 1;
+static const int kDatabaseTrackerCurrentSchemaVersion = 2;
+static const int kDatabaseTrackerCompatibleVersion = 1;
 
 const base::FilePath::CharType kTemporaryDirectoryPrefix[] =
     FILE_PATH_LITERAL("DeleteMe");
@@ -499,13 +499,15 @@ bool DatabaseTracker::UpgradeToCurrentVersion() {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
   sql::Transaction transaction(db_.get());
   if (!transaction.Begin() ||
-      !meta_table_->Init(db_.get(), kCurrentVersion, kCompatibleVersion) ||
-      (meta_table_->GetCompatibleVersionNumber() > kCurrentVersion) ||
+      !meta_table_->Init(db_.get(), kDatabaseTrackerCurrentSchemaVersion,
+                         kDatabaseTrackerCompatibleVersion) ||
+      (meta_table_->GetCompatibleVersionNumber() >
+       kDatabaseTrackerCurrentSchemaVersion) ||
       !databases_table_->Init())
     return false;
 
-  if (meta_table_->GetVersionNumber() < kCurrentVersion)
-    meta_table_->SetVersionNumber(kCurrentVersion);
+  if (meta_table_->GetVersionNumber() < kDatabaseTrackerCurrentSchemaVersion)
+    meta_table_->SetVersionNumber(kDatabaseTrackerCurrentSchemaVersion);
 
   return transaction.Commit();
 }

storage/browser/fileapi/file_system_quota_client.cc

@@ -58,8 +58,9 @@ void GetOriginsForHostOnFileTaskRunner(FileSystemContext* context,
     origins_ptr->insert(url::Origin::Create(origin));
 }
 
-void DidGetOrigins(storage::QuotaClient::GetOriginsCallback callback,
-                   std::set<url::Origin>* origins_ptr) {
+void DidGetFileSystemQuotaClientOrigins(
+    storage::QuotaClient::GetOriginsCallback callback,
+    std::set<url::Origin>* origins_ptr) {
   std::move(callback).Run(*origins_ptr);
 }
 
@@ -144,7 +145,7 @@ void FileSystemQuotaClient::GetOriginsForType(StorageType storage_type,
       base::BindOnce(&GetOriginsForTypeOnFileTaskRunner,
                      base::RetainedRef(file_system_context_), storage_type,
                      base::Unretained(origins_ptr)),
-      base::BindOnce(&DidGetOrigins, std::move(callback),
+      base::BindOnce(&DidGetFileSystemQuotaClientOrigins, std::move(callback),
                      base::Owned(origins_ptr)));
 }
 
@@ -166,7 +167,7 @@ void FileSystemQuotaClient::GetOriginsForHost(StorageType storage_type,
       base::BindOnce(&GetOriginsForHostOnFileTaskRunner,
                      base::RetainedRef(file_system_context_), storage_type,
                      host, base::Unretained(origins_ptr)),
-      base::BindOnce(&DidGetOrigins, std::move(callback),
+      base::BindOnce(&DidGetFileSystemQuotaClientOrigins, std::move(callback),
                      base::Owned(origins_ptr)));
 }
 

storage/browser/fileapi/sandbox_directory_database.cc

@@ -72,16 +72,17 @@ const base::FilePath::CharType kDirectoryDatabaseName[] =
     FILE_PATH_LITERAL("Paths");
 const char kChildLookupPrefix[] = "CHILD_OF:";
 const char kChildLookupSeparator[] = ":";
-const char kLastFileIdKey[] = "LAST_FILE_ID";
-const char kLastIntegerKey[] = "LAST_INTEGER";
-const int64_t kMinimumReportIntervalHours = 1;
-const char kInitStatusHistogramLabel[] = "FileSystem.DirectoryDatabaseInit";
-const char kDatabaseRepairHistogramLabel[] =
+const char kSandboxDirectoryLastFileIdKey[] = "LAST_FILE_ID";
+const char kSandboxDirectoryLastIntegerKey[] = "LAST_INTEGER";
+const int64_t kSandboxDirectoryMinimumReportIntervalHours = 1;
+const char kSandboxDirectoryInitStatusHistogramLabel[] =
+    "FileSystem.DirectoryDatabaseInit";
+const char kSandboxDirectoryDatabaseRepairHistogramLabel[] =
     "FileSystem.DirectoryDatabaseRepair";
 
 // These values are recorded in UMA. Changing existing values will invalidate
 // results for older Chrome releases. Only add new values.
-enum InitStatus {
+enum class SandboxDirectoryInitStatus {
   INIT_STATUS_OK = 0,
   INIT_STATUS_CORRUPTION,
   INIT_STATUS_IO_ERROR,
@@ -91,7 +92,7 @@ enum InitStatus {
 
 // These values are recorded in UMA. Changing existing values will invalidate
 // results for older Chrome releases. Only add new values.
-enum RepairResult {
+enum class SandboxDirectoryRepairResult {
   DB_REPAIR_SUCCEEDED = 0,
   DB_REPAIR_FAILED,
   DB_REPAIR_MAX
@@ -113,11 +114,11 @@ std::string GetChildListingKeyPrefix(
 }
 
 const char* LastFileIdKey() {
-  return kLastFileIdKey;
+  return kSandboxDirectoryLastFileIdKey;
 }
 
 const char* LastIntegerKey() {
-  return kLastIntegerKey;
+  return kSandboxDirectoryLastIntegerKey;
 }
 
 std::string GetFileLookupKey(
@@ -213,7 +214,7 @@ bool DatabaseCheckHelper::ScanDatabase() {
       // key: "CHILD_OF:<parent_id>:<name>"
       // value: "<child_id>"
       ++num_hierarchy_links_in_db_;
-    } else if (key == kLastFileIdKey) {
+    } else if (key == kSandboxDirectoryLastFileIdKey) {
       // key: "LAST_FILE_ID"
       // value: "<last_file_id>"
       if (last_file_id_ >= 0 ||
@@ -222,7 +223,7 @@ bool DatabaseCheckHelper::ScanDatabase() {
 
       if (last_file_id_ < 0)
         return false;
-    } else if (key == kLastIntegerKey) {
+    } else if (key == kSandboxDirectoryLastIntegerKey) {
       // key: "LAST_INTEGER"
       // value: "<last_integer>"
       if (last_integer_ >= 0 ||
@@ -751,12 +752,15 @@ bool SandboxDirectoryDatabase::Init(RecoveryOption recovery_option) {
       LOG(WARNING) << "Corrupted SandboxDirectoryDatabase detected."
                    << " Attempting to repair.";
       if (RepairDatabase(path)) {
-        UMA_HISTOGRAM_ENUMERATION(kDatabaseRepairHistogramLabel,
-                                  DB_REPAIR_SUCCEEDED, DB_REPAIR_MAX);
+        UMA_HISTOGRAM_ENUMERATION(
+            kSandboxDirectoryDatabaseRepairHistogramLabel,
+            SandboxDirectoryRepairResult::DB_REPAIR_SUCCEEDED,
+            SandboxDirectoryRepairResult::DB_REPAIR_MAX);
         return true;
       }
-      UMA_HISTOGRAM_ENUMERATION(kDatabaseRepairHistogramLabel,
-                                DB_REPAIR_FAILED, DB_REPAIR_MAX);
+      UMA_HISTOGRAM_ENUMERATION(kSandboxDirectoryDatabaseRepairHistogramLabel,
+                                SandboxDirectoryRepairResult::DB_REPAIR_FAILED,
+                                SandboxDirectoryRepairResult::DB_REPAIR_MAX);
       LOG(WARNING) << "Failed to repair SandboxDirectoryDatabase.";
       FALLTHROUGH;
     case DELETE_ON_CORRUPTION:
@@ -811,23 +815,29 @@ void SandboxDirectoryDatabase::ReportInitStatus(
     const leveldb::Status& status) {
   base::Time now = base::Time::Now();
   const base::TimeDelta minimum_interval =
-      base::TimeDelta::FromHours(kMinimumReportIntervalHours);
+      base::TimeDelta::FromHours(kSandboxDirectoryMinimumReportIntervalHours);
   if (last_reported_time_ + minimum_interval >= now)
     return;
   last_reported_time_ = now;
 
   if (status.ok()) {
-    UMA_HISTOGRAM_ENUMERATION(kInitStatusHistogramLabel,
-                              INIT_STATUS_OK, INIT_STATUS_MAX);
+    UMA_HISTOGRAM_ENUMERATION(kSandboxDirectoryInitStatusHistogramLabel,
+                              SandboxDirectoryInitStatus::INIT_STATUS_OK,
+                              SandboxDirectoryInitStatus::INIT_STATUS_MAX);
   } else if (status.IsCorruption()) {
-    UMA_HISTOGRAM_ENUMERATION(kInitStatusHistogramLabel,
-                              INIT_STATUS_CORRUPTION, INIT_STATUS_MAX);
+    UMA_HISTOGRAM_ENUMERATION(
+        kSandboxDirectoryInitStatusHistogramLabel,
+        SandboxDirectoryInitStatus::INIT_STATUS_CORRUPTION,
+        SandboxDirectoryInitStatus::INIT_STATUS_MAX);
   } else if (status.IsIOError()) {
-    UMA_HISTOGRAM_ENUMERATION(kInitStatusHistogramLabel,
-                              INIT_STATUS_IO_ERROR, INIT_STATUS_MAX);
+    UMA_HISTOGRAM_ENUMERATION(kSandboxDirectoryInitStatusHistogramLabel,
+                              SandboxDirectoryInitStatus::INIT_STATUS_IO_ERROR,
+                              SandboxDirectoryInitStatus::INIT_STATUS_MAX);
   } else {
-    UMA_HISTOGRAM_ENUMERATION(kInitStatusHistogramLabel,
-                              INIT_STATUS_UNKNOWN_ERROR, INIT_STATUS_MAX);
+    UMA_HISTOGRAM_ENUMERATION(
+        kSandboxDirectoryInitStatusHistogramLabel,
+        SandboxDirectoryInitStatus::INIT_STATUS_UNKNOWN_ERROR,
+        SandboxDirectoryInitStatus::INIT_STATUS_MAX);
   }
 }
 

storage/browser/fileapi/sandbox_file_system_backend_delegate.cc

@@ -90,13 +90,13 @@ std::set<std::string> GetKnownTypeStrings() {
   return known_type_strings;
 }
 
-class ObfuscatedOriginEnumerator
+class SandboxObfuscatedOriginEnumerator
     : public SandboxFileSystemBackendDelegate::OriginEnumerator {
  public:
-  explicit ObfuscatedOriginEnumerator(ObfuscatedFileUtil* file_util) {
+  explicit SandboxObfuscatedOriginEnumerator(ObfuscatedFileUtil* file_util) {
     enum_.reset(file_util->CreateOriginEnumerator());
   }
-  ~ObfuscatedOriginEnumerator() override = default;
+  ~SandboxObfuscatedOriginEnumerator() override = default;
 
   GURL Next() override { return enum_->Next(); }
 
@@ -109,12 +109,11 @@ class ObfuscatedOriginEnumerator
   std::unique_ptr<ObfuscatedFileUtil::AbstractOriginEnumerator> enum_;
 };
 
-void OpenFileSystemOnFileTaskRunner(
-    ObfuscatedFileUtil* file_util,
-    const GURL& origin_url,
-    FileSystemType type,
-    OpenFileSystemMode mode,
-    base::File::Error* error_ptr) {
+void OpenSandboxFileSystemOnFileTaskRunner(ObfuscatedFileUtil* file_util,
+                                           const GURL& origin_url,
+                                           FileSystemType type,
+                                           OpenFileSystemMode mode,
+                                           base::File::Error* error_ptr) {
   DCHECK(error_ptr);
   const bool create = (mode == OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT);
   file_util->GetDirectoryForOriginAndType(
@@ -233,7 +232,7 @@ SandboxFileSystemBackendDelegate::~SandboxFileSystemBackendDelegate() {
 
 SandboxFileSystemBackendDelegate::OriginEnumerator*
 SandboxFileSystemBackendDelegate::CreateOriginEnumerator() {
-  return new ObfuscatedOriginEnumerator(obfuscated_file_util());
+  return new SandboxObfuscatedOriginEnumerator(obfuscated_file_util());
 }
 
 base::FilePath
@@ -276,8 +275,9 @@ void SandboxFileSystemBackendDelegate::OpenFileSystem(
   base::File::Error* error_ptr = new base::File::Error;
   file_task_runner_->PostTaskAndReply(
       FROM_HERE,
-      base::BindOnce(&OpenFileSystemOnFileTaskRunner, obfuscated_file_util(),
-                     origin_url, type, mode, base::Unretained(error_ptr)),
+      base::BindOnce(&OpenSandboxFileSystemOnFileTaskRunner,
+                     obfuscated_file_util(), origin_url, type, mode,
+                     base::Unretained(error_ptr)),
       base::BindOnce(&DidOpenFileSystem, weak_factory_.GetWeakPtr(),
                      std::move(quota_callback),
                      base::BindOnce(std::move(callback), root_url, name),

storage/browser/fileapi/sandbox_origin_database.cc

@@ -29,12 +29,14 @@ namespace {
 const base::FilePath::CharType kOriginDatabaseName[] =
     FILE_PATH_LITERAL("Origins");
 const char kOriginKeyPrefix[] = "ORIGIN:";
-const char kLastPathKey[] = "LAST_PATH";
-const int64_t kMinimumReportIntervalHours = 1;
-const char kInitStatusHistogramLabel[] = "FileSystem.OriginDatabaseInit";
-const char kDatabaseRepairHistogramLabel[] = "FileSystem.OriginDatabaseRepair";
-
-enum InitStatus {
+const char kSandboxOriginLastPathKey[] = "LAST_PATH";
+const int64_t kSandboxOriginMinimumReportIntervalHours = 1;
+const char kSandboxOriginInitStatusHistogramLabel[] =
+    "FileSystem.OriginDatabaseInit";
+const char kSandboxOriginDatabaseRepairHistogramLabel[] =
+    "FileSystem.OriginDatabaseRepair";
+
+enum class InitSandboxOriginStatus {
   INIT_STATUS_OK = 0,
   INIT_STATUS_CORRUPTION,
   INIT_STATUS_IO_ERROR,
@@ -42,7 +44,7 @@ enum InitStatus {
   INIT_STATUS_MAX
 };
 
-enum RepairResult {
+enum class SandboxOriginRepairResult {
   DB_REPAIR_SUCCEEDED = 0,
   DB_REPAIR_FAILED,
   DB_REPAIR_MAX
@@ -54,7 +56,7 @@ std::string OriginToOriginKey(const std::string& origin) {
 }
 
 const char* LastPathKey() {
-  return kLastPathKey;
+  return kSandboxOriginLastPathKey;
 }
 
 }  // namespace
@@ -105,13 +107,16 @@ bool SandboxOriginDatabase::Init(InitOption init_option,
       LOG(WARNING) << "Attempting to repair SandboxOriginDatabase.";
 
       if (RepairDatabase(path)) {
-        UMA_HISTOGRAM_ENUMERATION(kDatabaseRepairHistogramLabel,
-                                  DB_REPAIR_SUCCEEDED, DB_REPAIR_MAX);
+        UMA_HISTOGRAM_ENUMERATION(
+            kSandboxOriginDatabaseRepairHistogramLabel,
+            SandboxOriginRepairResult::DB_REPAIR_SUCCEEDED,
+            SandboxOriginRepairResult::DB_REPAIR_MAX);
         LOG(WARNING) << "Repairing SandboxOriginDatabase completed.";
         return true;
       }
-      UMA_HISTOGRAM_ENUMERATION(kDatabaseRepairHistogramLabel,
-                                DB_REPAIR_FAILED, DB_REPAIR_MAX);
+      UMA_HISTOGRAM_ENUMERATION(kSandboxOriginDatabaseRepairHistogramLabel,
+                                SandboxOriginRepairResult::DB_REPAIR_FAILED,
+                                SandboxOriginRepairResult::DB_REPAIR_MAX);
       FALLTHROUGH;
     case DELETE_ON_CORRUPTION:
       if (!base::DeleteFile(file_system_directory_, true))
@@ -193,23 +198,28 @@ void SandboxOriginDatabase::HandleError(const base::Location& from_here,
 void SandboxOriginDatabase::ReportInitStatus(const leveldb::Status& status) {
   base::Time now = base::Time::Now();
   base::TimeDelta minimum_interval =
-      base::TimeDelta::FromHours(kMinimumReportIntervalHours);
+      base::TimeDelta::FromHours(kSandboxOriginMinimumReportIntervalHours);
   if (last_reported_time_ + minimum_interval >= now)
     return;
   last_reported_time_ = now;
 
   if (status.ok()) {
-    UMA_HISTOGRAM_ENUMERATION(kInitStatusHistogramLabel,
-                              INIT_STATUS_OK, INIT_STATUS_MAX);
+    UMA_HISTOGRAM_ENUMERATION(kSandboxOriginInitStatusHistogramLabel,
+                              InitSandboxOriginStatus::INIT_STATUS_OK,
+                              InitSandboxOriginStatus::INIT_STATUS_MAX);
   } else if (status.IsCorruption()) {
-    UMA_HISTOGRAM_ENUMERATION(kInitStatusHistogramLabel,
-                              INIT_STATUS_CORRUPTION, INIT_STATUS_MAX);
+    UMA_HISTOGRAM_ENUMERATION(kSandboxOriginInitStatusHistogramLabel,
+                              InitSandboxOriginStatus::INIT_STATUS_CORRUPTION,
+                              InitSandboxOriginStatus::INIT_STATUS_MAX);
   } else if (status.IsIOError()) {
-    UMA_HISTOGRAM_ENUMERATION(kInitStatusHistogramLabel,
-                              INIT_STATUS_IO_ERROR, INIT_STATUS_MAX);
+    UMA_HISTOGRAM_ENUMERATION(kSandboxOriginInitStatusHistogramLabel,
+                              InitSandboxOriginStatus::INIT_STATUS_IO_ERROR,
+                              InitSandboxOriginStatus::INIT_STATUS_MAX);
   } else {
-    UMA_HISTOGRAM_ENUMERATION(kInitStatusHistogramLabel,
-                              INIT_STATUS_UNKNOWN_ERROR, INIT_STATUS_MAX);
+    UMA_HISTOGRAM_ENUMERATION(
+        kSandboxOriginInitStatusHistogramLabel,
+        InitSandboxOriginStatus::INIT_STATUS_UNKNOWN_ERROR,
+        InitSandboxOriginStatus::INIT_STATUS_MAX);
   }
 }
 

storage/browser/quota/client_usage_tracker.cc

@@ -49,9 +49,10 @@ bool OriginSetContainsOrigin(const OriginSetByHost& origins,
   return itr != origins.end() && base::ContainsKey(itr->second, origin);
 }
 
-void DidGetGlobalUsageForLimitedGlobalUsage(UsageCallback callback,
-                                            int64_t total_global_usage,
-                                            int64_t global_unlimited_usage) {
+void DidGetGlobalClientUsageForLimitedGlobalClientUsage(
+    UsageCallback callback,
+    int64_t total_global_usage,
+    int64_t global_unlimited_usage) {
   std::move(callback).Run(total_global_usage - global_unlimited_usage);
 }
 
@@ -85,8 +86,9 @@ ClientUsageTracker::~ClientUsageTracker() {
 
 void ClientUsageTracker::GetGlobalLimitedUsage(UsageCallback callback) {
   if (!global_usage_retrieved_) {
-    GetGlobalUsage(base::BindOnce(&DidGetGlobalUsageForLimitedGlobalUsage,
-                                  std::move(callback)));
+    GetGlobalUsage(
+        base::BindOnce(&DidGetGlobalClientUsageForLimitedGlobalClientUsage,
+                       std::move(callback)));
     return;
   }
 

storage/browser/quota/quota_database.cc

@@ -29,8 +29,8 @@ namespace {
 
 // Definitions for database schema.
 
-const int kCurrentVersion = 5;
-const int kCompatibleVersion = 2;
+const int kQuotaDatabaseCurrentSchemaVersion = 5;
+const int kQuotaDatabaseCompatibleVersion = 2;
 
 const char kHostQuotaTable[] = "HostQuotaTable";
 const char kOriginInfoTable[] = "OriginInfoTable";
@@ -568,19 +568,21 @@ bool QuotaDatabase::EnsureDatabaseVersion() {
   static const size_t kIndexCount = arraysize(kIndexes);
   if (!sql::MetaTable::DoesTableExist(db_.get()))
     return CreateSchema(db_.get(), meta_table_.get(),
-                        kCurrentVersion, kCompatibleVersion,
-                        kTables, kTableCount,
+                        kQuotaDatabaseCurrentSchemaVersion,
+                        kQuotaDatabaseCompatibleVersion, kTables, kTableCount,
                         kIndexes, kIndexCount);
 
-  if (!meta_table_->Init(db_.get(), kCurrentVersion, kCompatibleVersion))
+  if (!meta_table_->Init(db_.get(), kQuotaDatabaseCurrentSchemaVersion,
+                         kQuotaDatabaseCompatibleVersion))
     return false;
 
-  if (meta_table_->GetCompatibleVersionNumber() > kCurrentVersion) {
+  if (meta_table_->GetCompatibleVersionNumber() >
+      kQuotaDatabaseCurrentSchemaVersion) {
     LOG(WARNING) << "Quota database is too new.";
     return false;
   }
 
-  if (meta_table_->GetVersionNumber() < kCurrentVersion) {
+  if (meta_table_->GetVersionNumber() < kQuotaDatabaseCurrentSchemaVersion) {
     if (!UpgradeSchema(meta_table_->GetVersionNumber()))
       return ResetSchema();
   }