Replace 'incognito' with 'OffTheRecord' in DatabaseTracker.

DatabaseTracker uses the term 'incognito' with the meaning of
'in-memory'. This is used for all profile types that are OffTheRecord
(including incognito, guest, and non-primary OTRs).
To fix the possible misinterpretation, 'incognito' is replaced with
'OffTheRecord'.

This CL does not make any behavioral change and is just for better code
readability.

Bug: 968028
Change-Id: Ifce346865d9d054883ab45679fd3a87144e88bd0
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2201377
Commit-Queue: Victor Costan <pwnall@chromium.org>
Reviewed-by: Ken Buchanan <kenrb@chromium.org>
Reviewed-by: Victor Costan <pwnall@chromium.org>
Cr-Commit-Position: refs/heads/master@{#768893}

content/browser/renderer_host/web_database_host_impl.cc

@@ -116,8 +116,8 @@ void WebDatabaseHostImpl::OpenFileValidated(const base::string16& vfs_file_name,
   std::string origin_identifier;
   base::string16 database_name;
 
-  // When in incognito mode, we want to make sure that all DB files are
-  // removed when the incognito browser context goes away, so we add the
+  // When in OffTheRecord mode, we want to make sure that all DB files are
+  // removed when the OffTheRecord browser context goes away, so we add the
   // SQLITE_OPEN_DELETEONCLOSE flag when opening all files, and keep
   // open handles to them in the database tracker to make sure they're
   // around for as long as needed.
@@ -131,14 +131,14 @@ void WebDatabaseHostImpl::OpenFileValidated(const base::string16& vfs_file_name,
     base::FilePath db_file = DatabaseUtil::GetFullFilePathForVfsFile(
         db_tracker_.get(), vfs_file_name);
     if (!db_file.empty()) {
-      if (db_tracker_->IsIncognitoProfile()) {
-        tracked_file = db_tracker_->GetIncognitoFile(vfs_file_name);
+      if (db_tracker_->IsOffTheRecordProfile()) {
+        tracked_file = db_tracker_->GetOffTheRecordFile(vfs_file_name);
         if (!tracked_file) {
           file = VfsBackend::OpenFile(
               db_file, desired_flags | SQLITE_OPEN_DELETEONCLOSE);
           if (!(desired_flags & SQLITE_OPEN_DELETEONCLOSE)) {
-            tracked_file =
-                db_tracker_->SaveIncognitoFile(vfs_file_name, std::move(file));
+            tracked_file = db_tracker_->SaveOffTheRecordFile(vfs_file_name,
+                                                             std::move(file));
           }
         }
       } else {
@@ -288,20 +288,20 @@ void WebDatabaseHostImpl::DatabaseDeleteFile(
   base::FilePath db_file =
       DatabaseUtil::GetFullFilePathForVfsFile(db_tracker_.get(), vfs_file_name);
   if (!db_file.empty()) {
-    // In order to delete a journal file in incognito mode, we only need to
+    // In order to delete a journal file in OffTheRecord mode, we only need to
     // close the open handle to it that's stored in the database tracker.
-    if (db_tracker_->IsIncognitoProfile()) {
+    if (db_tracker_->IsOffTheRecordProfile()) {
       const base::string16 wal_suffix(base::ASCIIToUTF16("-wal"));
       base::string16 sqlite_suffix;
 
       // WAL files can be deleted without having previously been opened.
-      if (!db_tracker_->HasSavedIncognitoFileHandle(vfs_file_name) &&
+      if (!db_tracker_->HasSavedOffTheRecordFileHandle(vfs_file_name) &&
           DatabaseUtil::CrackVfsFileName(vfs_file_name, nullptr, nullptr,
                                          &sqlite_suffix) &&
           sqlite_suffix == wal_suffix) {
         error_code = SQLITE_OK;
       } else {
-        db_tracker_->CloseIncognitoFileHandle(vfs_file_name);
+        db_tracker_->CloseOffTheRecordFileHandle(vfs_file_name);
         error_code = SQLITE_OK;
       }
     } else {

storage/browser/database/database_tracker.cc

@@ -33,8 +33,8 @@ namespace storage {
 
 const base::FilePath::CharType kDatabaseDirectoryName[] =
     FILE_PATH_LITERAL("databases");
-const base::FilePath::CharType kIncognitoDatabaseDirectoryName[] =
-    FILE_PATH_LITERAL("databases-incognito");
+const base::FilePath::CharType kOffTheRecordDatabaseDirectoryName[] =
+    FILE_PATH_LITERAL("databases-off-the-record");
 const base::FilePath::CharType kTrackerDatabaseFileName[] =
     FILE_PATH_LITERAL("Databases.db");
 static const int kDatabaseTrackerCurrentSchemaVersion = 2;
@@ -85,13 +85,13 @@ OriginInfo::OriginInfo(const std::string& origin_identifier, int64_t total_size)
     : origin_identifier_(origin_identifier), total_size_(total_size) {}
 
 DatabaseTracker::DatabaseTracker(const base::FilePath& profile_path,
-                                 bool is_incognito,
+                                 bool is_off_the_record,
                                  SpecialStoragePolicy* special_storage_policy,
                                  QuotaManagerProxy* quota_manager_proxy)
-    : is_incognito_(is_incognito),
+    : is_off_the_record_(is_off_the_record),
       profile_path_(profile_path),
-      db_dir_(is_incognito_
-                  ? profile_path_.Append(kIncognitoDatabaseDirectoryName)
+      db_dir_(is_off_the_record_
+                  ? profile_path_.Append(kOffTheRecordDatabaseDirectoryName)
                   : profile_path_.Append(kDatabaseDirectoryName)),
       db_(new sql::Database()),
       special_storage_policy_(special_storage_policy),
@@ -257,7 +257,7 @@ void DatabaseTracker::CloseTrackerDatabaseAndClearCaches() {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
   ClearAllCachedOriginInfo();
 
-  if (!is_incognito_) {
+  if (!is_off_the_record_) {
     meta_table_.reset(nullptr);
     databases_table_.reset(nullptr);
     db_->Close();
@@ -271,16 +271,16 @@ base::FilePath DatabaseTracker::GetOriginDirectory(
 
   base::string16 origin_directory;
 
-  if (!is_incognito_) {
+  if (!is_off_the_record_) {
     origin_directory = base::UTF8ToUTF16(origin_identifier);
   } else {
-    auto it = incognito_origin_directories_.find(origin_identifier);
-    if (it != incognito_origin_directories_.end()) {
+    auto it = off_the_record_origin_directories_.find(origin_identifier);
+    if (it != off_the_record_origin_directories_.end()) {
       origin_directory = it->second;
     } else {
-      origin_directory =
-          base::NumberToString16(incognito_origin_directories_generator_++);
-      incognito_origin_directories_[origin_identifier] = origin_directory;
+      origin_directory = base::NumberToString16(
+          off_the_record_origin_directories_generator_++);
+      off_the_record_origin_directories_[origin_identifier] = origin_directory;
     }
   }
 
@@ -425,18 +425,18 @@ bool DatabaseTracker::DeleteOrigin(const std::string& origin_identifier,
   base::DeleteFileRecursively(origin_dir);
   base::DeleteFileRecursively(new_origin_dir);  // Might fail on windows.
 
-  if (is_incognito_) {
-    incognito_origin_directories_.erase(origin_identifier);
+  if (is_off_the_record_) {
+    off_the_record_origin_directories_.erase(origin_identifier);
 
     // TODO(jsbell): Consider alternate data structures to avoid this
     // linear scan.
-    for (auto it = incognito_file_handles_.begin();
-         it != incognito_file_handles_.end();) {
+    for (auto it = off_the_record_file_handles_.begin();
+         it != off_the_record_file_handles_.end();) {
       std::string id;
       if (DatabaseUtil::CrackVfsFileName(it->first, &id, nullptr, nullptr) &&
           id == origin_identifier) {
         delete it->second;
-        it = incognito_file_handles_.erase(it);
+        it = off_the_record_file_handles_.erase(it);
       } else {
         ++it;
       }
@@ -508,8 +508,8 @@ bool DatabaseTracker::LazyInit() {
     is_initialized_ =
         base::CreateDirectory(db_dir_) &&
         (db_->is_open() ||
-         (is_incognito_ ? db_->OpenInMemory() :
-          db_->Open(kTrackerDatabaseFullPath))) &&
+         (is_off_the_record_ ? db_->OpenInMemory()
+                             : db_->Open(kTrackerDatabaseFullPath))) &&
         UpgradeToCurrentVersion();
     if (!is_initialized_) {
       databases_table_.reset(nullptr);
@@ -786,64 +786,64 @@ int DatabaseTracker::DeleteDataForOrigin(const url::Origin& origin,
   return net::OK;
 }
 
-const base::File* DatabaseTracker::GetIncognitoFile(
+const base::File* DatabaseTracker::GetOffTheRecordFile(
     const base::string16& vfs_file_name) const {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
-  DCHECK(is_incognito_);
-  auto it = incognito_file_handles_.find(vfs_file_name);
-  if (it != incognito_file_handles_.end())
+  DCHECK(is_off_the_record_);
+  auto it = off_the_record_file_handles_.find(vfs_file_name);
+  if (it != off_the_record_file_handles_.end())
     return it->second;
 
   return nullptr;
 }
 
-const base::File* DatabaseTracker::SaveIncognitoFile(
+const base::File* DatabaseTracker::SaveOffTheRecordFile(
     const base::string16& vfs_file_name,
     base::File file) {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
-  DCHECK(is_incognito_);
+  DCHECK(is_off_the_record_);
   if (!file.IsValid())
     return nullptr;
 
   base::File* to_insert = new base::File(std::move(file));
-  auto rv =
-      incognito_file_handles_.insert(std::make_pair(vfs_file_name, to_insert));
+  auto rv = off_the_record_file_handles_.insert(
+      std::make_pair(vfs_file_name, to_insert));
   DCHECK(rv.second);
   return rv.first->second;
 }
 
-void DatabaseTracker::CloseIncognitoFileHandle(
+void DatabaseTracker::CloseOffTheRecordFileHandle(
     const base::string16& vfs_file_name) {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
-  DCHECK(is_incognito_);
-  DCHECK(incognito_file_handles_.find(vfs_file_name) !=
-         incognito_file_handles_.end());
+  DCHECK(is_off_the_record_);
+  DCHECK(off_the_record_file_handles_.find(vfs_file_name) !=
+         off_the_record_file_handles_.end());
 
-  auto it = incognito_file_handles_.find(vfs_file_name);
-  if (it != incognito_file_handles_.end()) {
+  auto it = off_the_record_file_handles_.find(vfs_file_name);
+  if (it != off_the_record_file_handles_.end()) {
     delete it->second;
-    incognito_file_handles_.erase(it);
+    off_the_record_file_handles_.erase(it);
   }
 }
 
-bool DatabaseTracker::HasSavedIncognitoFileHandle(
+bool DatabaseTracker::HasSavedOffTheRecordFileHandle(
     const base::string16& vfs_file_name) const {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
-  return (incognito_file_handles_.find(vfs_file_name) !=
-          incognito_file_handles_.end());
+  return (off_the_record_file_handles_.find(vfs_file_name) !=
+          off_the_record_file_handles_.end());
 }
 
-void DatabaseTracker::DeleteIncognitoDBDirectory() {
+void DatabaseTracker::DeleteOffTheRecordDBDirectory() {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
   is_initialized_ = false;
 
-  for (auto& pair : incognito_file_handles_)
+  for (auto& pair : off_the_record_file_handles_)
     delete pair.second;
 
-  base::FilePath incognito_db_dir =
-      profile_path_.Append(kIncognitoDatabaseDirectoryName);
-  if (base::DirectoryExists(incognito_db_dir))
-    base::DeleteFileRecursively(incognito_db_dir);
+  base::FilePath off_the_record_db_dir =
+      profile_path_.Append(kOffTheRecordDatabaseDirectoryName);
+  if (base::DirectoryExists(off_the_record_db_dir))
+    base::DeleteFileRecursively(off_the_record_db_dir);
 }
 
 void DatabaseTracker::ClearSessionOnlyOrigins() {
@@ -891,8 +891,8 @@ void DatabaseTracker::Shutdown() {
     return;
   }
   shutting_down_ = true;
-  if (is_incognito_)
-    DeleteIncognitoDBDirectory();
+  if (is_off_the_record_)
+    DeleteOffTheRecordDBDirectory();
   else if (!force_keep_session_state_)
     ClearSessionOnlyOrigins();
   CloseTrackerDatabaseAndClearCaches();

storage/browser/database/database_tracker.h

@@ -98,7 +98,7 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) DatabaseTracker
   };
 
   DatabaseTracker(const base::FilePath& profile_path,
-                  bool is_incognito,
+                  bool is_off_the_record,
                   SpecialStoragePolicy* special_storage_policy,
                   QuotaManagerProxy* quota_manager_proxy);
 
@@ -164,16 +164,18 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) DatabaseTracker
   virtual int DeleteDataForOrigin(const url::Origin& origin,
                                   net::CompletionOnceCallback callback);
 
-  bool IsIncognitoProfile() const { return is_incognito_; }
+  bool IsOffTheRecordProfile() const { return is_off_the_record_; }
 
-  const base::File* GetIncognitoFile(const base::string16& vfs_file_path) const;
-  const base::File* SaveIncognitoFile(const base::string16& vfs_file_path,
-                                      base::File file);
-  void CloseIncognitoFileHandle(const base::string16& vfs_file_path);
-  bool HasSavedIncognitoFileHandle(const base::string16& vfs_file_path) const;
+  const base::File* GetOffTheRecordFile(
+      const base::string16& vfs_file_path) const;
+  const base::File* SaveOffTheRecordFile(const base::string16& vfs_file_path,
+                                         base::File file);
+  void CloseOffTheRecordFileHandle(const base::string16& vfs_file_path);
+  bool HasSavedOffTheRecordFileHandle(
+      const base::string16& vfs_file_path) const;
 
   // Shutdown the database tracker, deleting database files if the tracker is
-  // used for an incognito profile.
+  // used for an OffTheRecord profile.
   void Shutdown();
   // Disables the exit-time deletion of session-only data.
   void SetForceKeepSessionState();
@@ -217,8 +219,9 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) DatabaseTracker
   // virtual for unit-testing only.
   virtual ~DatabaseTracker();
 
-  // Deletes the directory that stores all DBs in incognito mode, if it exists.
-  void DeleteIncognitoDBDirectory();
+  // Deletes the directory that stores all DBs in OffTheRecord mode, if it
+  // exists.
+  void DeleteOffTheRecordDBDirectory();
 
   // Deletes session-only databases. Blocks databases from being created/opened.
   void ClearSessionOnlyOrigins();
@@ -276,7 +279,7 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) DatabaseTracker
   base::FilePath GetOriginDirectory(const std::string& origin_identifier);
 
   bool is_initialized_ = false;
-  const bool is_incognito_;
+  const bool is_off_the_record_;
   bool force_keep_session_state_ = false;
   bool shutting_down_ = false;
   const base::FilePath profile_path_;
@@ -309,19 +312,20 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) DatabaseTracker
   // The database tracker thread we're supposed to run file IO on.
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
 
-  // When in incognito mode, store a DELETE_ON_CLOSE handle to each
-  // main DB and journal file that was accessed. When the incognito profile
+  // When in OffTheRecord mode, store a DELETE_ON_CLOSE handle to each
+  // main DB and journal file that was accessed. When the OffTheRecord profile
   // goes away (or when the browser crashes), all these handles will be
   // closed, and the files will be deleted.
-  std::map<base::string16, base::File*> incognito_file_handles_;
-
-  // In a non-incognito profile, all DBs in an origin are stored in a directory
-  // named after the origin. In an incognito profile though, we do not want the
-  // directory structure to reveal the origins visited by the user (in case the
-  // browser process crashes and those directories are not deleted). So we use
-  // this map to assign directory names that do not reveal this information.
-  std::map<std::string, base::string16> incognito_origin_directories_;
-  int incognito_origin_directories_generator_ = 0;
+  std::map<base::string16, base::File*> off_the_record_file_handles_;
+
+  // In a non-OffTheRecord profile, all DBs in an origin are stored in a
+  // directory named after the origin. In an OffTheRecord profile though, we do
+  // not want the directory structure to reveal the origins visited by the user
+  // (in case the browser process crashes and those directories are not
+  // deleted). So we use this map to assign directory names that do not reveal
+  // this information.
+  std::map<std::string, base::string16> off_the_record_origin_directories_;
+  int off_the_record_origin_directories_generator_ = 0;
 
   FRIEND_TEST_ALL_PREFIXES(DatabaseTracker, TestHelper);
 };