Deprecate WEBKIT thread

content/browser/in_process_webkit/dom_storage_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/dom_storage_context.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/file_path.h"
@@ skipping 72 matching lines @@
   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;
 
   // Not being on the WEBKIT thread here means we are running in a unit test
   // where no clean up is needed.
-  if (BrowserThread::CurrentlyOn(BrowserThread::WEBKIT)) {
+  if (BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED)) {
     ClearLocalState(data_path_.Append(kLocalStorageDirectory),
                     special_storage_policy_,
                     clear_local_state_on_exit_);
   }
 }
 
 int64 DOMStorageContext::AllocateStorageAreaId() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   return ++last_storage_area_id_;
 }
 
 int64 DOMStorageContext::AllocateSessionStorageNamespaceId() {
   if (BrowserThread::CurrentlyOn(BrowserThread::UI))
     return ++last_session_storage_namespace_id_on_ui_thread_;
   return --last_session_storage_namespace_id_on_io_thread_;
 }
 
 int64 DOMStorageContext::CloneSessionStorage(int64 original_id) {
-  DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   int64 clone_id = AllocateSessionStorageNamespaceId();
   BrowserThread::PostTask(
-      BrowserThread::WEBKIT, FROM_HERE,
+      BrowserThread::WEBKIT_DEPRECATED, FROM_HERE,
       base::Bind(&DOMStorageContext::CompleteCloningSessionStorage, this,
                  original_id, clone_id));
   return clone_id;
 }
 
 void DOMStorageContext::RegisterStorageArea(DOMStorageArea* storage_area) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   int64 id = storage_area->id();
   DCHECK(!GetStorageArea(id));
   storage_area_map_[id] = storage_area;
 }
 
 void DOMStorageContext::UnregisterStorageArea(DOMStorageArea* storage_area) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   int64 id = storage_area->id();
   DCHECK(GetStorageArea(id));
   storage_area_map_.erase(id);
 }
 
 DOMStorageArea* DOMStorageContext::GetStorageArea(int64 id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   StorageAreaMap::iterator iter = storage_area_map_.find(id);
   if (iter == storage_area_map_.end())
     return NULL;
   return iter->second;
 }
 
 void DOMStorageContext::DeleteSessionStorageNamespace(int64 namespace_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   StorageNamespaceMap::iterator iter =
       storage_namespace_map_.find(namespace_id);
   if (iter == storage_namespace_map_.end())
     return;
   DCHECK(iter->second->dom_storage_type() == DOM_STORAGE_SESSION);
   delete iter->second;
   storage_namespace_map_.erase(iter);
 }
 
 DOMStorageNamespace* DOMStorageContext::GetStorageNamespace(
     int64 id, bool allocation_allowed) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   StorageNamespaceMap::iterator iter = storage_namespace_map_.find(id);
   if (iter != storage_namespace_map_.end())
     return iter->second;
   if (!allocation_allowed)
     return NULL;
   if (id == kLocalStorageNamespaceId)
     return CreateLocalStorage();
   return CreateSessionStorage(id);
 }
 
@@ skipping 46 matching lines @@
       continue;
 
     file_util::FileEnumerator::FindInfo find_info;
     file_enumerator.GetFindInfo(&find_info);
     if (file_util::HasFileBeenModifiedSince(find_info, cutoff))
       file_util::Delete(path, false);
   }
 }
 
 void DOMStorageContext::DeleteLocalStorageFile(const FilePath& file_path) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
 
   // Make sure that we don't delete a database that's currently being accessed
   // by unloading all of the databases temporarily.
   // TODO(bulach): both this method and DeleteDataModifiedSince could purge
   // only the memory used by the specific file instead of all memory at once.
   // See http://crbug.com/32000
   PurgeMemory();
   file_util::Delete(file_path, false);
 }
 
 void DOMStorageContext::DeleteLocalStorageForOrigin(const string16& origin_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   DeleteLocalStorageFile(GetLocalStorageFilePath(origin_id));
 }
 
 void DOMStorageContext::DeleteAllLocalStorageFiles() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
 
   // Make sure that we don't delete a database that's currently being accessed
   // by unloading all of the databases temporarily.
   PurgeMemory();
 
   file_util::FileEnumerator file_enumerator(
       data_path_.Append(kLocalStorageDirectory), false,
       file_util::FileEnumerator::FILES);
   for (FilePath file_path = file_enumerator.Next(); !file_path.empty();
        file_path = file_enumerator.Next()) {
@@ skipping 15 matching lines @@
 DOMStorageNamespace* DOMStorageContext::CreateSessionStorage(
     int64 namespace_id) {
   DOMStorageNamespace* new_namespace =
       DOMStorageNamespace::CreateSessionStorageNamespace(this, namespace_id);
   RegisterStorageNamespace(new_namespace);
   return new_namespace;
 }
 
 void DOMStorageContext::RegisterStorageNamespace(
     DOMStorageNamespace* storage_namespace) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   int64 id = storage_namespace->id();
   DCHECK(!GetStorageNamespace(id, false));
   storage_namespace_map_[id] = storage_namespace;
 }
 
 /* static */
 void DOMStorageContext::CompleteCloningSessionStorage(
     DOMStorageContext* context, int64 existing_id, int64 clone_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   DOMStorageNamespace* existing_namespace =
       context->GetStorageNamespace(existing_id, false);
   // If nothing exists, then there's nothing to clone.
   if (existing_namespace)
     context->RegisterStorageNamespace(existing_namespace->Copy(clone_id));
 }
 
 FilePath DOMStorageContext::GetLocalStorageFilePath(
     const string16& origin_id) const {
   FilePath storageDir = data_path_.Append(
       DOMStorageContext::kLocalStorageDirectory);
   FilePath::StringType id =
       webkit_glue::WebStringToFilePathString(origin_id);
   return storageDir.Append(id.append(kLocalStorageExtension));
 }