Delete indexedDBs from the cookie tree ui.

content/browser/in_process_webkit/indexed_db_context.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.h"
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
 #include "base/string_util.h"
 #include "base/task.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/in_process_webkit/indexed_db_quota_client.h"
 #include "content/browser/in_process_webkit/webkit_context.h"
 #include "content/common/content_switches.h"
-#include "googleurl/src/gurl.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebCString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebIDBDatabase.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebIDBFactory.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityOrigin.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebString.h"
 #include "webkit/database/database_util.h"
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/quota/quota_manager.h"
 #include "webkit/quota/special_storage_policy.h"
 
 using webkit_database::DatabaseUtil;
 using WebKit::WebIDBDatabase;
 using WebKit::WebIDBFactory;
 using WebKit::WebSecurityOrigin;
 
 namespace {
 
+void GetAllOriginsAndPaths(

[michaeln, 2011/08/23 20:39:48]

Consolidated this directory listing stuff in one place instead of having it
replicated.

+    const FilePath& indexeddb_path,
+    std::vector<GURL>* origins,
+    std::vector<FilePath>* file_paths) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  if (indexeddb_path.empty())
+    return;
+  file_util::FileEnumerator file_enumerator(indexeddb_path,
+      false, file_util::FileEnumerator::DIRECTORIES);
+  for (FilePath file_path = file_enumerator.Next(); !file_path.empty();
+       file_path = file_enumerator.Next()) {
+    if (file_path.Extension() == IndexedDBContext::kIndexedDBExtension) {
+      WebKit::WebString origin_id_webstring =
+          webkit_glue::FilePathToWebString(file_path.BaseName());
+      origins->push_back(
+          DatabaseUtil::GetOriginFromIdentifier(origin_id_webstring));
+      if (file_paths)
+        file_paths->push_back(file_path);
+    }
+  }
+}
+
 void ClearLocalState(
     const FilePath& indexeddb_path,
     scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy) {
-  file_util::FileEnumerator file_enumerator(
-      indexeddb_path, false, file_util::FileEnumerator::FILES);
-  // TODO(pastarmovj): We might need to consider exchanging this loop for
-  // something more efficient in the future.
-  for (FilePath file_path = file_enumerator.Next(); !file_path.empty();
-       file_path = file_enumerator.Next()) {
-    if (file_path.Extension() != IndexedDBContext::kIndexedDBExtension)
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  std::vector<GURL> origins;
+  std::vector<FilePath> file_paths;
+  GetAllOriginsAndPaths(indexeddb_path, &origins, &file_paths);
+  DCHECK_EQ(origins.size(), file_paths.size());
+  std::vector<FilePath>::const_iterator file_path_iter = file_paths.begin();
+  for (std::vector<GURL>::const_iterator iter = origins.begin();
+       iter != origins.end(); ++iter, ++file_path_iter) {
+    if (special_storage_policy->IsStorageProtected(*iter))
       continue;
-    WebSecurityOrigin origin =
-        WebSecurityOrigin::createFromDatabaseIdentifier(
-            webkit_glue::FilePathToWebString(file_path.BaseName()));
-    if (special_storage_policy->IsStorageProtected(GURL(origin.toString())))
-      continue;
-    file_util::Delete(file_path, false);

[michaeln, 2011/08/23 21:54:39]

Looks like this was never updated in the switch from sqlite to leveldb backing
either. Changed to operate on directories now and also had to update the test in
IndexedDBBrowserTest::ClearLocalState.

+    file_util::Delete(*file_path_iter, true);
   }
 }
 
 }  // namespace
 
 const FilePath::CharType IndexedDBContext::kIndexedDBDirectory[] =
     FILE_PATH_LITERAL("IndexedDB");
 
 const FilePath::CharType IndexedDBContext::kIndexedDBExtension[] =
     FILE_PATH_LITERAL(".leveldb");
@@ skipping 34 matching lines @@
 };
 
 IndexedDBContext::IndexedDBContext(
     WebKitContext* webkit_context,
     quota::SpecialStoragePolicy* special_storage_policy,
     quota::QuotaManagerProxy* quota_manager_proxy,
     base::MessageLoopProxy* webkit_thread_loop)
     : clear_local_state_on_exit_(false),
       special_storage_policy_(special_storage_policy),
       quota_manager_proxy_(quota_manager_proxy) {
-  data_path_ = webkit_context->data_path().Append(kIndexedDBDirectory);
+  if (!webkit_context->is_incognito())

[michaeln, 2011/08/23 20:39:48]

Made sure to not look in the filesystem for incognito.

+    data_path_ = webkit_context->data_path().Append(kIndexedDBDirectory);
   if (quota_manager_proxy &&
       !CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess)) {
     quota_manager_proxy->RegisterClient(
         new IndexedDBQuotaClient(webkit_thread_loop, this));
   }
 }
 
 IndexedDBContext::~IndexedDBContext() {
   WebKit::WebIDBFactory* factory = idb_factory_.release();
   if (factory)
     BrowserThread::DeleteSoon(BrowserThread::WEBKIT, FROM_HERE, factory);
 
-  if (clear_local_state_on_exit_) {
+  if (clear_local_state_on_exit_ && !data_path_.empty()) {
     // No WEBKIT thread here means we are running in a unit test where no clean
     // up is needed.
     BrowserThread::PostTask(BrowserThread::WEBKIT, FROM_HERE,
         NewRunnableFunction(&ClearLocalState, data_path_,
                             special_storage_policy_));
   }
 }
 
 WebIDBFactory* IndexedDBContext::GetIDBFactory() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
   if (!idb_factory_.get())
     idb_factory_.reset(WebIDBFactory::create());
   DCHECK(idb_factory_.get());
   return idb_factory_.get();
 }
 
-FilePath IndexedDBContext::GetIndexedDBFilePath(
-    const string16& origin_id) const {
-  FilePath::StringType id =
-      webkit_glue::WebStringToFilePathString(origin_id).append(
-          FILE_PATH_LITERAL(".indexeddb"));
-  return data_path_.Append(id.append(kIndexedDBExtension));
-}
-
 // Note: This is not called in response to a UI action in Content Settings. Only
 // extension data deleter and quota manager currently call this.
 void IndexedDBContext::DeleteIndexedDBForOrigin(const GURL& origin_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  if (data_path_.empty() || !IsInOriginSet(origin_url))
+    return;
   string16 origin_id = DatabaseUtil::GetOriginIdentifier(origin_url);
   FilePath idb_directory = GetIndexedDBFilePath(origin_id);
   if (idb_directory.BaseName().value().substr(0, strlen("chrome-extension")) ==
-      FILE_PATH_LITERAL("chrome-extension") ||
+          FILE_PATH_LITERAL("chrome-extension") ||
       connection_count_.find(origin_url) == connection_count_.end()) {
     EnsureDiskUsageCacheInitialized(origin_url);
-    file_util::Delete(idb_directory, true /*recursive*/);
+    bool deleted = file_util::Delete(idb_directory, true /*recursive*/);
     QueryDiskAndUpdateQuotaUsage(origin_url);
+    if (deleted) {
+      RemoveFromOriginSet(origin_url);
+      origin_size_map_.erase(origin_url);
+    }
   }
 }
 
 bool IndexedDBContext::IsUnlimitedStorageGranted(
     const GURL& origin) const {
   return special_storage_policy_->IsStorageUnlimited(origin);
 }
 
-// TODO(dgrogan): Merge this code with the similar loop in
-// BrowsingDataIndexedDBHelperImpl::FetchIndexedDBInfoInWebKitThread.
-void IndexedDBContext::GetAllOriginIdentifiers(
-    std::vector<string16>* origin_ids) {
+void IndexedDBContext::GetAllOrigins(std::vector<GURL>* origins) {

[michaeln, 2011/08/23 20:39:48]

This can get called frequently, utilize a cache of the origins using indexedDBs
instead of repeatedly accessing the filesystem.

   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
-  file_util::FileEnumerator file_enumerator(data_path_,
-      false, file_util::FileEnumerator::DIRECTORIES);
-  for (FilePath file_path = file_enumerator.Next(); !file_path.empty();
-       file_path = file_enumerator.Next()) {
-    if (file_path.Extension() == IndexedDBContext::kIndexedDBExtension) {
-      WebKit::WebString origin_id_webstring =
-          webkit_glue::FilePathToWebString(file_path.BaseName());
-      origin_ids->push_back(origin_id_webstring);
-    }
+  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);
   }
 }
 
 int64 IndexedDBContext::GetOriginDiskUsage(const GURL& origin_url) {
-  return ResetDiskUsageCache(origin_url);
+  if (data_path_.empty() || !IsInOriginSet(origin_url))
+    return 0;
+  EnsureDiskUsageCacheInitialized(origin_url);
+  return origin_size_map_[origin_url];

[michaeln, 2011/08/23 20:39:48]

Depend more heavily on the cached size values here so the set of values reported
to the QM are consistent.

+}
+
+base::Time IndexedDBContext::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 IndexedDBContext::ConnectionOpened(const GURL& origin_url) {
   if (quota_manager_proxy()) {
     quota_manager_proxy()->NotifyStorageAccessed(
         quota::QuotaClient::kIndexedDatabase, origin_url,
         quota::kStorageTypeTemporary);
   }
+  AddToOriginSet(origin_url);
   connection_count_[origin_url]++;
   QueryAvailableQuota(origin_url);
   EnsureDiskUsageCacheInitialized(origin_url);
 }
 
 void IndexedDBContext::ConnectionClosed(const GURL& origin_url) {
   DCHECK(connection_count_[origin_url] > 0);
   if (quota_manager_proxy()) {
     quota_manager_proxy()->NotifyStorageAccessed(
         quota::QuotaClient::kIndexedDatabase, origin_url,
         quota::kStorageTypeTemporary);
   }
   connection_count_[origin_url]--;
   if (connection_count_[origin_url] == 0) {
     QueryDiskAndUpdateQuotaUsage(origin_url);
     connection_count_.erase(origin_url);
   }
 }
 
 void IndexedDBContext::TransactionComplete(const GURL& origin_url) {
   DCHECK(connection_count_[origin_url] > 0);
   QueryDiskAndUpdateQuotaUsage(origin_url);
   QueryAvailableQuota(origin_url);
 }
 
+FilePath IndexedDBContext::GetIndexedDBFilePath(
+    const string16& origin_id) const {
+  if (data_path_.empty())
+    return FilePath();
+  FilePath::StringType id =
+      webkit_glue::WebStringToFilePathString(origin_id).append(
+          FILE_PATH_LITERAL(".indexeddb"));
+  return data_path_.Append(id.append(kIndexedDBExtension));
+}
+
 bool IndexedDBContext::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 IndexedDBContext::IsOverQuota(const GURL& origin_url) {
   const int kOneAdditionalByte = 1;
   return WouldBeOverQuota(origin_url, kOneAdditionalByte);
 }
 
 quota::QuotaManagerProxy* IndexedDBContext::quota_manager_proxy() {
   return quota_manager_proxy_;
 }
 
 int64 IndexedDBContext::ReadUsageFromDisk(const GURL& origin_url) const {
   string16 origin_id = DatabaseUtil::GetOriginIdentifier(origin_url);
   FilePath file_path = GetIndexedDBFilePath(origin_id);
-  return file_util::ComputeDirectorySize(file_path);
+  return file_path.empty() ? 0 : file_util::ComputeDirectorySize(file_path);
 }
 
 void IndexedDBContext::EnsureDiskUsageCacheInitialized(const GURL& origin_url) {
   if (origin_size_map_.find(origin_url) == origin_size_map_.end())
-    ResetDiskUsageCache(origin_url);
+    origin_size_map_[origin_url] = ReadUsageFromDisk(origin_url);
 }
 
 void IndexedDBContext::QueryDiskAndUpdateQuotaUsage(const GURL& origin_url) {
   int64 former_disk_usage = origin_size_map_[origin_url];
   int64 current_disk_usage = ReadUsageFromDisk(origin_url);
   int64 difference = current_disk_usage - former_disk_usage;
   if (difference) {
     origin_size_map_[origin_url] = current_disk_usage;
     // quota_manager_proxy() is NULL in unit tests.
     if (quota_manager_proxy())
@@ skipping 24 matching lines @@
   if (!quota_manager_proxy()->quota_manager())
     return;
   IndexedDBGetUsageAndQuotaCallback* callback =
       new IndexedDBGetUsageAndQuotaCallback(this, origin_url);
   quota_manager_proxy()->quota_manager()->GetUsageAndQuota(
       origin_url,
       quota::kStorageTypeTemporary,
       callback);
 }
 
-int64 IndexedDBContext::ResetDiskUsageCache(const GURL& origin_url) {
-  origin_size_map_[origin_url] = ReadUsageFromDisk(origin_url);
-  return origin_size_map_[origin_url];
+std::set<GURL>* IndexedDBContext::GetOriginSet() {
+  if (!origin_set_.get()) {
+    origin_set_.reset(new std::set<GURL>);
+    std::vector<GURL> origins;
+    GetAllOriginsAndPaths(data_path_, &origins, NULL);
+    for (std::vector<GURL>::const_iterator iter = origins.begin();
+         iter != origins.end(); ++iter) {
+      origin_set_->insert(*iter);
+    }
+  }
+  return origin_set_.get();
 }
+
+void IndexedDBContext::ResetCaches() {
+  origin_set_.reset();
+  origin_size_map_.clear();
+  space_available_map_.clear();
+}