RefCounted types should not have public destructors, content/browser part 1

content/browser/in_process_webkit/indexed_db_context_impl.cc

 // Copyright (c) 2011 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 "content/browser/in_process_webkit/indexed_db_context_impl.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 88 matching lines @@
       quota_manager_proxy_(quota_manager_proxy) {
   if (!data_path.empty())
     data_path_ = data_path.Append(kIndexedDBDirectory);
   if (quota_manager_proxy &&
       !CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess)) {
     quota_manager_proxy->RegisterClient(
         new IndexedDBQuotaClient(webkit_thread_loop, this));
   }
 }
 
-IndexedDBContextImpl::~IndexedDBContextImpl() {
-  WebKit::WebIDBFactory* factory = idb_factory_.release();
-  if (factory) {
-    if (!BrowserThread::DeleteSoon(BrowserThread::WEBKIT_DEPRECATED,
-                                   FROM_HERE, factory))
-      delete factory;
-  }
-
-  if (data_path_.empty())
-    return;
-
-  if (save_session_state_)
-    return;
-
-  bool has_session_only_databases =
-      special_storage_policy_.get() &&
-      special_storage_policy_->HasSessionOnlyOrigins();
-
-  // Clearning only session-only databases, and there are none.
-  if (!clear_local_state_on_exit_ && !has_session_only_databases)
-    return;
-
-  // No WEBKIT thread here means we are running in a unit test where no clean
-  // up is needed.
-  BrowserThread::PostTask(
-      BrowserThread::WEBKIT_DEPRECATED, FROM_HERE,
-      base::Bind(&ClearLocalState, data_path_, clear_local_state_on_exit_,
-                 special_storage_policy_));
-}
-
 WebIDBFactory* IndexedDBContextImpl::GetIDBFactory() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   if (!idb_factory_.get()) {
     // Prime our cache of origins with existing databases so we can
     // detect when dbs are newly created.
     GetOriginSet();
     idb_factory_.reset(WebIDBFactory::create());
   }
   return idb_factory_.get();
 }
 
-void IndexedDBContextImpl::DeleteForOrigin(const GURL& origin_url) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
-  if (data_path_.empty() || !IsInOriginSet(origin_url))
-    return;
-  // TODO(michaeln): When asked to delete an origin with open connections,
-  // forcibly close those connections then delete.
-  if (connection_count_.find(origin_url) == connection_count_.end()) {
-    string16 origin_id = DatabaseUtil::GetOriginIdentifier(origin_url);
-    FilePath idb_directory = GetIndexedDBFilePath(origin_id);
-    EnsureDiskUsageCacheInitialized(origin_url);
-    bool deleted = file_util::Delete(idb_directory, true /*recursive*/);
-    QueryDiskAndUpdateQuotaUsage(origin_url);
-    if (deleted) {
-      RemoveFromOriginSet(origin_url);
-      origin_size_map_.erase(origin_url);
-      space_available_map_.erase(origin_url);
-    }
-  }
-}
-
-FilePath IndexedDBContextImpl::GetFilePathForTesting(
-  const string16& origin_id) const {
-  return GetIndexedDBFilePath(origin_id);
-}
-
 std::vector<GURL> IndexedDBContextImpl::GetAllOrigins() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   std::vector<GURL> origins;
   std::set<GURL>* origins_set = GetOriginSet();
   for (std::set<GURL>::const_iterator iter = origins_set->begin();
        iter != origins_set->end(); ++iter) {
     origins.push_back(*iter);
   }
   return origins;
 }
 
 int64 IndexedDBContextImpl::GetOriginDiskUsage(const GURL& origin_url) {
   if (data_path_.empty() || !IsInOriginSet(origin_url))
     return 0;
   EnsureDiskUsageCacheInitialized(origin_url);
   return origin_size_map_[origin_url];
 }
 
 base::Time IndexedDBContextImpl::GetOriginLastModified(const GURL& origin_url) {
   if (data_path_.empty() || !IsInOriginSet(origin_url))
     return base::Time();
   string16 origin_id = DatabaseUtil::GetOriginIdentifier(origin_url);
   FilePath idb_directory = GetIndexedDBFilePath(origin_id);
   base::PlatformFileInfo file_info;
   if (!file_util::GetFileInfo(idb_directory, &file_info))
     return base::Time();
   return file_info.last_modified;
 }
 
+void IndexedDBContextImpl::DeleteForOrigin(const GURL& origin_url) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
+  if (data_path_.empty() || !IsInOriginSet(origin_url))
+    return;
+  // TODO(michaeln): When asked to delete an origin with open connections,
+  // forcibly close those connections then delete.
+  if (connection_count_.find(origin_url) == connection_count_.end()) {
+    string16 origin_id = DatabaseUtil::GetOriginIdentifier(origin_url);
+    FilePath idb_directory = GetIndexedDBFilePath(origin_id);
+    EnsureDiskUsageCacheInitialized(origin_url);
+    bool deleted = file_util::Delete(idb_directory, true /*recursive*/);
+    QueryDiskAndUpdateQuotaUsage(origin_url);
+    if (deleted) {
+      RemoveFromOriginSet(origin_url);
+      origin_size_map_.erase(origin_url);
+      space_available_map_.erase(origin_url);
+    }
+  }
+}
+
+FilePath IndexedDBContextImpl::GetFilePathForTesting(
+  const string16& origin_id) const {
+  return GetIndexedDBFilePath(origin_id);
+}
+
 void IndexedDBContextImpl::ConnectionOpened(const GURL& origin_url) {
   if (quota_manager_proxy()) {
     quota_manager_proxy()->NotifyStorageAccessed(
         quota::QuotaClient::kIndexedDatabase, origin_url,
         quota::kStorageTypeTemporary);
   }
   connection_count_[origin_url]++;
   if (AddToOriginSet(origin_url)) {
     // A newly created db, notify the quota system.
     QueryDiskAndUpdateQuotaUsage(origin_url);
@@ skipping 16 matching lines @@
     connection_count_.erase(origin_url);
   }
 }
 
 void IndexedDBContextImpl::TransactionComplete(const GURL& origin_url) {
   DCHECK(connection_count_[origin_url] > 0);
   QueryDiskAndUpdateQuotaUsage(origin_url);
   QueryAvailableQuota(origin_url);
 }
 
-FilePath IndexedDBContextImpl::GetIndexedDBFilePath(
-    const string16& origin_id) const {
-  DCHECK(!data_path_.empty());
-  FilePath::StringType id =
-      webkit_glue::WebStringToFilePathString(origin_id).append(
-          FILE_PATH_LITERAL(".indexeddb"));
-  return data_path_.Append(id.append(kIndexedDBExtension));
-}
-
 bool IndexedDBContextImpl::WouldBeOverQuota(const GURL& origin_url,
                                             int64 additional_bytes) {
   if (space_available_map_.find(origin_url) == space_available_map_.end()) {
     // We haven't heard back from the QuotaManager yet, just let it through.
     return false;
   }
   bool over_quota = additional_bytes > space_available_map_[origin_url];
   return over_quota;
 }
 
 bool IndexedDBContextImpl::IsOverQuota(const GURL& origin_url) {
   const int kOneAdditionalByte = 1;
   return WouldBeOverQuota(origin_url, kOneAdditionalByte);
 }
 
 quota::QuotaManagerProxy* IndexedDBContextImpl::quota_manager_proxy() {
   return quota_manager_proxy_;
 }
 
+IndexedDBContextImpl::~IndexedDBContextImpl() {
+  WebKit::WebIDBFactory* factory = idb_factory_.release();
+  if (factory) {
+    if (!BrowserThread::DeleteSoon(BrowserThread::WEBKIT_DEPRECATED,
+                                   FROM_HERE, factory))
+      delete factory;
+  }
+
+  if (data_path_.empty())
+    return;
+
+  if (save_session_state_)
+    return;
+
+  bool has_session_only_databases =
+      special_storage_policy_.get() &&
+      special_storage_policy_->HasSessionOnlyOrigins();
+
+  // Clearning only session-only databases, and there are none.
+  if (!clear_local_state_on_exit_ && !has_session_only_databases)
+    return;
+
+  // No WEBKIT thread here means we are running in a unit test where no clean
+  // up is needed.
+  BrowserThread::PostTask(
+      BrowserThread::WEBKIT_DEPRECATED, FROM_HERE,
+      base::Bind(&ClearLocalState, data_path_, clear_local_state_on_exit_,
+                 special_storage_policy_));
+}
+
+FilePath IndexedDBContextImpl::GetIndexedDBFilePath(
+    const string16& origin_id) const {
+  DCHECK(!data_path_.empty());
+  FilePath::StringType id =
+      webkit_glue::WebStringToFilePathString(origin_id).append(
+          FILE_PATH_LITERAL(".indexeddb"));
+  return data_path_.Append(id.append(kIndexedDBExtension));
+}
+
 int64 IndexedDBContextImpl::ReadUsageFromDisk(const GURL& origin_url) const {
   if (data_path_.empty())
     return 0;
   string16 origin_id = DatabaseUtil::GetOriginIdentifier(origin_url);
   FilePath file_path = GetIndexedDBFilePath(origin_id);
   return file_util::ComputeDirectorySize(file_path);
 }
 
 void IndexedDBContextImpl::EnsureDiskUsageCacheInitialized(
     const GURL& origin_url) {
@@ skipping 70 matching lines @@
     }
   }
   return origin_set_.get();
 }
 
 void IndexedDBContextImpl::ResetCaches() {
   origin_set_.reset();
   origin_size_map_.clear();
   space_available_map_.clear();
 }