Unwire the clear on exit preference from the storage systems.

webkit/database/database_tracker.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/database/database_tracker.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 80 matching lines @@
     : origin_(origin), total_size_(total_size) {}
 
 DatabaseTracker::DatabaseTracker(
     const FilePath& profile_path,
     bool is_incognito,
     quota::SpecialStoragePolicy* special_storage_policy,
     quota::QuotaManagerProxy* quota_manager_proxy,
     base::MessageLoopProxy* db_tracker_thread)
     : is_initialized_(false),
       is_incognito_(is_incognito),
-      clear_local_state_on_exit_(false),
-      save_session_state_(false),
+      force_keep_session_state_(false),
       shutting_down_(false),
       profile_path_(profile_path),
       db_dir_(is_incognito_ ?
               profile_path_.Append(kIncognitoDatabaseDirectoryName) :
               profile_path_.Append(kDatabaseDirectoryName)),
       db_(new sql::Connection()),
       databases_table_(NULL),
       meta_table_(NULL),
       special_storage_policy_(special_storage_policy),
       quota_manager_proxy_(quota_manager_proxy),
@@ skipping 690 matching lines @@
   for (FileHandlesMap::iterator it = incognito_file_handles_.begin();
        it != incognito_file_handles_.end(); it++)
     base::ClosePlatformFile(it->second);
 
   FilePath incognito_db_dir =
       profile_path_.Append(kIncognitoDatabaseDirectoryName);
   if (file_util::DirectoryExists(incognito_db_dir))
     file_util::Delete(incognito_db_dir, true);
 }
 
-void DatabaseTracker::ClearLocalState(bool clear_all_databases) {
+void DatabaseTracker::ClearSessionOnlyOrigins() {
   shutting_down_ = true;
 
   bool has_session_only_databases =
       special_storage_policy_.get() &&
       special_storage_policy_->HasSessionOnlyOrigins();
 
   // Clearing only session-only databases, and there are none.
-  if (!clear_all_databases && !has_session_only_databases)
+  if (!has_session_only_databases)
     return;
 
   if (!LazyInit())
     return;
 
   std::vector<string16> origin_identifiers;
   GetAllOriginIdentifiers(&origin_identifiers);
 
   for (std::vector<string16>::iterator origin = origin_identifiers.begin();
        origin != origin_identifiers.end(); ++origin) {
     GURL origin_url =
         webkit_database::DatabaseUtil::GetOriginFromIdentifier(*origin);
-    if (!clear_all_databases &&
-        !special_storage_policy_->IsStorageSessionOnly(origin_url)) {
+    if (!special_storage_policy_->IsStorageSessionOnly(origin_url))
       continue;
-    }
-    if (special_storage_policy_.get() &&
-        special_storage_policy_->IsStorageProtected(origin_url)) {
+    if (special_storage_policy_->IsStorageProtected(origin_url))
       continue;
-    }
     webkit_database::OriginInfo origin_info;
     std::vector<string16> databases;
     GetOriginInfo(*origin, &origin_info);
     origin_info.GetAllDatabaseNames(&databases);
 
     for (std::vector<string16>::iterator database = databases.begin();
          database != databases.end(); ++database) {
       base::PlatformFile file_handle = base::CreatePlatformFile(
           GetFullDBFilePath(*origin, *database),
           base::PLATFORM_FILE_OPEN_ALWAYS |
@@ skipping 10 matching lines @@
 
 void DatabaseTracker::Shutdown() {
   DCHECK(db_tracker_thread_.get());
   DCHECK(db_tracker_thread_->BelongsToCurrentThread());
   if (shutting_down_) {
     NOTREACHED();
     return;
   }
   if (is_incognito_)
     DeleteIncognitoDBDirectory();
-  else if (!save_session_state_)
-    ClearLocalState(clear_local_state_on_exit_);
+  else if (!force_keep_session_state_)
+    ClearSessionOnlyOrigins();
 }
 
-void DatabaseTracker::SetClearLocalStateOnExit(bool clear_local_state_on_exit) {
+void DatabaseTracker::SetForceKeepSessionState() {
   DCHECK(db_tracker_thread_.get());
   if (!db_tracker_thread_->BelongsToCurrentThread()) {
     db_tracker_thread_->PostTask(
         FROM_HERE,
-        base::Bind(&DatabaseTracker::SetClearLocalStateOnExit, this,
-                   clear_local_state_on_exit));
+        base::Bind(&DatabaseTracker::SetForceKeepSessionState, this));
     return;
   }
-  if (shutting_down_) {
-    NOTREACHED();
-    return;
-  }
-  clear_local_state_on_exit_ = clear_local_state_on_exit;
-}
-
-void DatabaseTracker::SaveSessionState() {
-  DCHECK(db_tracker_thread_.get());
-  if (!db_tracker_thread_->BelongsToCurrentThread()) {
-    db_tracker_thread_->PostTask(
-        FROM_HERE,
-        base::Bind(&DatabaseTracker::SaveSessionState, this));
-    return;
-  }
-  save_session_state_ = true;
+  force_keep_session_state_ = true;
 }
 
 }  // namespace webkit_database