Deprecate WEBKIT thread

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/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 20 matching lines @@
 using WebKit::WebIDBDatabase;
 using WebKit::WebIDBFactory;
 using WebKit::WebSecurityOrigin;
 
 namespace {
 
 void GetAllOriginsAndPaths(
     const FilePath& indexeddb_path,
     std::vector<GURL>* origins,
     std::vector<FilePath>* file_paths) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   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);
     }
   }
 }
 
 // If clear_all_databases is true, deletes all databases not protected by
 // special storage policy. Otherwise deletes session-only databases.
 void ClearLocalState(
     const FilePath& indexeddb_path,
     bool clear_all_databases,
     scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   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 (!clear_all_databases &&
         !special_storage_policy->IsStorageSessionOnly(*iter)) {
       continue;
@@ skipping 26 matching lines @@
     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 (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, FROM_HERE,
+      BrowserThread::WEBKIT_DEPRECATED, FROM_HERE,
       base::Bind(&ClearLocalState, data_path_, clear_local_state_on_exit_,
                  special_storage_policy_));
 }
 
 WebIDBFactory* IndexedDBContext::GetIDBFactory() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  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 IndexedDBContext::DeleteIndexedDBForOrigin(const GURL& origin_url) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  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);
     }
   }
 }
 
 void IndexedDBContext::GetAllOrigins(std::vector<GURL>* origins) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   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) {
   if (data_path_.empty() || !IsInOriginSet(origin_url))
     return 0;
@@ skipping 109 matching lines @@
                                         quota::QuotaStatusCode status,
                                         int64 usage, int64 quota) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(status == quota::kQuotaStatusOk || status == quota::kQuotaErrorAbort)
       << "status was " << status;
   if (status == quota::kQuotaErrorAbort) {
     // We seem to no longer care to wait around for the answer.
     return;
   }
   BrowserThread::PostTask(
-      BrowserThread::WEBKIT, FROM_HERE,
+      BrowserThread::WEBKIT_DEPRECATED, FROM_HERE,
       base::Bind(&IndexedDBContext::GotUpdatedQuota, this, origin_url, usage,
                  quota));
 }
 
 void IndexedDBContext::GotUpdatedQuota(const GURL& origin_url, int64 usage,
                                        int64 quota) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   space_available_map_[origin_url] = quota - usage;
 }
 
 void IndexedDBContext::QueryAvailableQuota(const GURL& origin_url) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
     if (quota_manager_proxy())
       BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
           base::Bind(&IndexedDBContext::QueryAvailableQuota, this, origin_url));
     return;
   }
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!quota_manager_proxy()->quota_manager())
     return;
   quota_manager_proxy()->quota_manager()->GetUsageAndQuota(
@@ skipping 14 matching lines @@
     }
   }
   return origin_set_.get();
 }
 
 void IndexedDBContext::ResetCaches() {
   origin_set_.reset();
   origin_size_map_.clear();
   space_available_map_.clear();
 }