Deprecate WEBKIT thread

content/browser/in_process_webkit/indexed_db_dispatcher_host.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_dispatcher_host.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/in_process_webkit/indexed_db_callbacks.h"
@@ skipping 34 matching lines @@
 using WebKit::WebIDBObjectStore;
 using WebKit::WebIDBTransaction;
 using WebKit::WebSecurityOrigin;
 using WebKit::WebSerializedScriptValue;
 using WebKit::WebVector;
 
 namespace {
 
 template <class T>
 void DeleteOnWebKitThread(T* obj) {
-  if (!BrowserThread::DeleteSoon(BrowserThread::WEBKIT, FROM_HERE, obj))
+  if (!BrowserThread::DeleteSoon(BrowserThread::WEBKIT_DEPRECATED,
+                                 FROM_HERE, obj))
     delete obj;
 }
 
 }
 
 IndexedDBDispatcherHost::IndexedDBDispatcherHost(
     int process_id, WebKitContext* webkit_context)
     : webkit_context_(webkit_context),
       ALLOW_THIS_IN_INITIALIZER_LIST(database_dispatcher_host_(
           new DatabaseDispatcherHost(this))),
       ALLOW_THIS_IN_INITIALIZER_LIST(index_dispatcher_host_(
           new IndexDispatcherHost(this))),
       ALLOW_THIS_IN_INITIALIZER_LIST(object_store_dispatcher_host_(
           new ObjectStoreDispatcherHost(this))),
       ALLOW_THIS_IN_INITIALIZER_LIST(cursor_dispatcher_host_(
           new CursorDispatcherHost(this))),
       ALLOW_THIS_IN_INITIALIZER_LIST(transaction_dispatcher_host_(
           new TransactionDispatcherHost(this))),
       process_id_(process_id) {
   DCHECK(webkit_context_.get());
 }
 
 IndexedDBDispatcherHost::~IndexedDBDispatcherHost() {
 }
 
 void IndexedDBDispatcherHost::OnChannelClosing() {
   BrowserMessageFilter::OnChannelClosing();
 
   bool success = BrowserThread::PostTask(
-      BrowserThread::WEBKIT, FROM_HERE,
+      BrowserThread::WEBKIT_DEPRECATED, FROM_HERE,
       base::Bind(&IndexedDBDispatcherHost::ResetDispatcherHosts, this));
 
   if (!success)
     ResetDispatcherHosts();
 }
 
 void IndexedDBDispatcherHost::ResetDispatcherHosts() {
   // It is important that the various *_dispatcher_host_ members are reset
   // on the WebKit thread, since there might be incoming messages on that
   // thread, and we must not reset the dispatcher hosts until after those
   // messages are processed.
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT) ||
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED) ||
          CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess));
 
   database_dispatcher_host_.reset();
   index_dispatcher_host_.reset();
   object_store_dispatcher_host_.reset();
   cursor_dispatcher_host_.reset();
   transaction_dispatcher_host_.reset();
 }
 
 void IndexedDBDispatcherHost::OverrideThreadForMessage(
     const IPC::Message& message,
     BrowserThread::ID* thread) {
   if (IPC_MESSAGE_CLASS(message) == IndexedDBMsgStart)
-    *thread = BrowserThread::WEBKIT;
+    *thread = BrowserThread::WEBKIT_DEPRECATED;
 }
 
 bool IndexedDBDispatcherHost::OnMessageReceived(const IPC::Message& message,
                                                 bool* message_was_ok) {
   if (IPC_MESSAGE_CLASS(message) != IndexedDBMsgStart)
     return false;
 
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
 
   bool handled =
       database_dispatcher_host_->OnMessageReceived(message, message_was_ok) ||
       index_dispatcher_host_->OnMessageReceived(message, message_was_ok) ||
       object_store_dispatcher_host_->OnMessageReceived(
           message, message_was_ok) ||
       cursor_dispatcher_host_->OnMessageReceived(message, message_was_ok) ||
       transaction_dispatcher_host_->OnMessageReceived(message, message_was_ok);
 
   if (!handled) {
@@ skipping 60 matching lines @@
     return 0;
   }
   int32 id = transaction_dispatcher_host_->map_.Add(idb_transaction);
   idb_transaction->setCallbacks(
       new IndexedDBTransactionCallbacks(this, thread_id, id));
   transaction_dispatcher_host_->transaction_url_map_[id] = url;
   return id;
 }
 
 WebIDBCursor* IndexedDBDispatcherHost::GetCursorFromId(int32 cursor_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   return cursor_dispatcher_host_->map_.Lookup(cursor_id);
 }
 
 void IndexedDBDispatcherHost::OnIDBFactoryGetDatabaseNames(
     const IndexedDBHostMsg_FactoryGetDatabaseNames_Params& params) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   FilePath base_path = webkit_context_->data_path();
   FilePath indexed_db_path;
   if (!base_path.empty()) {
     indexed_db_path = base_path.Append(
         IndexedDBContext::kIndexedDBDirectory);
   }
 
   // TODO(jorlow): This doesn't support file:/// urls properly. We probably need
   //               to add some toString method to WebSecurityOrigin that doesn't
   //               return null for them.  Look at
   //               DatabaseUtil::GetOriginFromIdentifier.
   WebSecurityOrigin origin(
       WebSecurityOrigin::createFromDatabaseIdentifier(params.origin));
   GURL origin_url(origin.toString());
 
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
 
   Context()->GetIDBFactory()->getDatabaseNames(
       new IndexedDBCallbacks<WebDOMStringList>(this, params.thread_id,
       params.response_id), origin, NULL,
       webkit_glue::FilePathToWebString(indexed_db_path));
 }
 
 void IndexedDBDispatcherHost::OnIDBFactoryOpen(
     const IndexedDBHostMsg_FactoryOpen_Params& params) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   FilePath base_path = webkit_context_->data_path();
   FilePath indexed_db_path;
   if (!base_path.empty()) {
     indexed_db_path = base_path.Append(
         IndexedDBContext::kIndexedDBDirectory);
   }
 
   // TODO(jorlow): This doesn't support file:/// urls properly. We probably need
   //               to add some toString method to WebSecurityOrigin that doesn't
   //               return null for them.  Look at
   //               DatabaseUtil::GetOriginFromIdentifier.
   WebSecurityOrigin origin(
       WebSecurityOrigin::createFromDatabaseIdentifier(params.origin));
   GURL origin_url(origin.toString());
 
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
 
   // TODO(dgrogan): Don't let a non-existing database be opened (and therefore
   // created) if this origin is already over quota.
   Context()->GetIDBFactory()->open(
       params.name,
       new IndexedDBCallbacks<WebIDBDatabase>(this, params.thread_id,
                                              params.response_id, origin_url),
       origin, NULL, webkit_glue::FilePathToWebString(indexed_db_path));
 }
 
 void IndexedDBDispatcherHost::OnIDBFactoryDeleteDatabase(
     const IndexedDBHostMsg_FactoryDeleteDatabase_Params& params) {
   FilePath base_path = webkit_context_->data_path();
   FilePath indexed_db_path;
   if (!base_path.empty()) {
     indexed_db_path = base_path.Append(
         IndexedDBContext::kIndexedDBDirectory);
   }
 
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   Context()->GetIDBFactory()->deleteDatabase(
       params.name,
       new IndexedDBCallbacks<WebSerializedScriptValue>(this,
                                                        params.thread_id,
                                                        params.response_id),
       WebSecurityOrigin::createFromDatabaseIdentifier(params.origin), NULL,
       webkit_glue::FilePathToWebString(indexed_db_path));
 }
 
 void IndexedDBDispatcherHost::TransactionComplete(int32 transaction_id) {
   Context()->TransactionComplete(
       transaction_dispatcher_host_->transaction_url_map_[transaction_id]);
 }
 
 //////////////////////////////////////////////////////////////////////
 // Helper templates.
 //
 
 template <typename ObjectType>
 ObjectType* IndexedDBDispatcherHost::GetOrTerminateProcess(
     IDMap<ObjectType, IDMapOwnPointer>* map, int32 return_object_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   ObjectType* return_object = map->Lookup(return_object_id);
   if (!return_object) {
     content::RecordAction(UserMetricsAction("BadMessageTerminate_IDBMF"));
     BadMessageReceived();
   }
   return return_object;
 }
 
 template <typename ReplyType, typename MapObjectType, typename Method>
 void IndexedDBDispatcherHost::SyncGetter(
@@ skipping 79 matching lines @@
 
   WebDOMStringList web_object_stores = idb_database->objectStoreNames();
   object_stores->reserve(web_object_stores.length());
   for (unsigned i = 0; i < web_object_stores.length(); ++i)
     object_stores->push_back(web_object_stores.item(i));
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnCreateObjectStore(
     const IndexedDBHostMsg_DatabaseCreateObjectStore_Params& params,
     int32* object_store_id, WebKit::WebExceptionCode* ec) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   WebIDBDatabase* idb_database = parent_->GetOrTerminateProcess(
       &map_, params.idb_database_id);
   WebIDBTransaction* idb_transaction = parent_->GetOrTerminateProcess(
       &parent_->transaction_dispatcher_host_->map_, params.transaction_id);
   if (!idb_database || !idb_transaction)
     return;
 
   *ec = 0;
   WebIDBObjectStore* object_store = idb_database->createObjectStore(
       params.name, params.key_path, params.auto_increment,
       *idb_transaction, *ec);
   *object_store_id = *ec ? 0 : parent_->Add(object_store);
   if (parent_->Context()->IsOverQuota(
       database_url_map_[params.idb_database_id])) {
     idb_transaction->abort();
   }
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnDeleteObjectStore(
     int32 idb_database_id,
     const string16& name,
     int32 transaction_id,
     WebKit::WebExceptionCode* ec) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   WebIDBDatabase* idb_database = parent_->GetOrTerminateProcess(
       &map_, idb_database_id);
   WebIDBTransaction* idb_transaction = parent_->GetOrTerminateProcess(
       &parent_->transaction_dispatcher_host_->map_, transaction_id);
   if (!idb_database || !idb_transaction)
     return;
 
   *ec = 0;
   idb_database->deleteObjectStore(name, *idb_transaction, *ec);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnSetVersion(
     int32 idb_database_id,
     int32 thread_id,
     int32 response_id,
     const string16& version,
     WebKit::WebExceptionCode* ec) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   WebIDBDatabase* idb_database = parent_->GetOrTerminateProcess(
       &map_, idb_database_id);
   if (!idb_database)
     return;
 
   *ec = 0;
   idb_database->setVersion(
       version,
       new IndexedDBCallbacks<WebIDBTransaction>(parent_, thread_id, response_id,
           database_url_map_[idb_database_id]),
@@ skipping 111 matching lines @@
 }
 
 void IndexedDBDispatcherHost::IndexDispatcherHost::OnUnique(
     int32 object_id, bool* unique) {
   parent_->SyncGetter<bool>(&map_, object_id, unique, &WebIDBIndex::unique);
 }
 
 void IndexedDBDispatcherHost::IndexDispatcherHost::OnOpenObjectCursor(
     const IndexedDBHostMsg_IndexOpenCursor_Params& params,
     WebKit::WebExceptionCode* ec) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   WebIDBIndex* idb_index = parent_->GetOrTerminateProcess(
       &map_, params.idb_index_id);
   WebIDBTransaction* idb_transaction = parent_->GetOrTerminateProcess(
       &parent_->transaction_dispatcher_host_->map_, params.transaction_id);
   if (!idb_transaction || !idb_index)
     return;
 
   *ec = 0;
   scoped_ptr<WebIDBCallbacks> callbacks(
       new IndexedDBCallbacks<WebIDBCursor>(parent_, params.thread_id,
                                            params.response_id, -1));
   idb_index->openObjectCursor(
       WebIDBKeyRange(params.lower_key, params.upper_key, params.lower_open,
                      params.upper_open),
       params.direction, callbacks.release(), *idb_transaction, *ec);
 }
 
 void IndexedDBDispatcherHost::IndexDispatcherHost::OnOpenKeyCursor(
     const IndexedDBHostMsg_IndexOpenCursor_Params& params,
     WebKit::WebExceptionCode* ec) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   WebIDBIndex* idb_index = parent_->GetOrTerminateProcess(
       &map_, params.idb_index_id);
   WebIDBTransaction* idb_transaction = parent_->GetOrTerminateProcess(
       &parent_->transaction_dispatcher_host_->map_, params.transaction_id);
   if (!idb_transaction || !idb_index)
     return;
 
   *ec = 0;
   scoped_ptr<WebIDBCallbacks> callbacks(
       new IndexedDBCallbacks<WebIDBCursor>(parent_, params.thread_id,
                                            params.response_id, -1));
   idb_index->openKeyCursor(
       WebIDBKeyRange(params.lower_key, params.upper_key, params.lower_open,
                      params.upper_open),
       params.direction, callbacks.release(), *idb_transaction, *ec);
 }
 
 void IndexedDBDispatcherHost::IndexDispatcherHost::OnCount(
     const IndexedDBHostMsg_IndexCount_Params& params,
     WebKit::WebExceptionCode* ec) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   WebIDBIndex* idb_index = parent_->GetOrTerminateProcess(
       &map_, params.idb_index_id);
   WebIDBTransaction* idb_transaction = parent_->GetOrTerminateProcess(
       &parent_->transaction_dispatcher_host_->map_, params.transaction_id);
   if (!idb_transaction || !idb_index)
     return;
 
   *ec = 0;
   scoped_ptr<WebIDBCallbacks> callbacks(
       new IndexedDBCallbacks<WebSerializedScriptValue>(parent_,
                                                        params.thread_id,
                                                        params.response_id));
   idb_index->count(
       WebIDBKeyRange(params.lower_key, params.upper_key, params.lower_open,
                      params.upper_open),
       callbacks.release(), *idb_transaction, *ec);
 }
 
 void IndexedDBDispatcherHost::IndexDispatcherHost::OnGetObject(
     int idb_index_id,
     int32 thread_id,
     int32 response_id,
     const IndexedDBKey& key,
     int32 transaction_id,
     WebKit::WebExceptionCode* ec) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   WebIDBIndex* idb_index = parent_->GetOrTerminateProcess(
       &map_, idb_index_id);
   WebIDBTransaction* idb_transaction = parent_->GetOrTerminateProcess(
       &parent_->transaction_dispatcher_host_->map_, transaction_id);
   if (!idb_transaction || !idb_index)
     return;
 
   *ec = 0;
   scoped_ptr<WebIDBCallbacks> callbacks(
       new IndexedDBCallbacks<WebSerializedScriptValue>(parent_, thread_id,
                                                        response_id));
   idb_index->getObject(key, callbacks.release(), *idb_transaction, *ec);
 }
 
 void IndexedDBDispatcherHost::IndexDispatcherHost::OnGetKey(
     int idb_index_id,
     int32 thread_id,
     int32 response_id,
     const IndexedDBKey& key,
     int32 transaction_id,
     WebKit::WebExceptionCode* ec) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   WebIDBIndex* idb_index = parent_->GetOrTerminateProcess(
       &map_, idb_index_id);
   WebIDBTransaction* idb_transaction = parent_->GetOrTerminateProcess(
       &parent_->transaction_dispatcher_host_->map_, transaction_id);
   if (!idb_transaction || !idb_index)
     return;
 
   *ec = 0;
   scoped_ptr<WebIDBCallbacks> callbacks(
       new IndexedDBCallbacks<WebIDBKey>(parent_, thread_id, response_id));
@@ skipping 72 matching lines @@
     index_names->push_back(web_index_names.item(i));
 }
 
 void IndexedDBDispatcherHost::ObjectStoreDispatcherHost::OnGet(
     int idb_object_store_id,
     int32 thread_id,
     int32 response_id,
     const IndexedDBKey& key,
     int32 transaction_id,
     WebKit::WebExceptionCode* ec) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   WebIDBObjectStore* idb_object_store = parent_->GetOrTerminateProcess(
       &map_, idb_object_store_id);
   WebIDBTransaction* idb_transaction = parent_->GetOrTerminateProcess(
       &parent_->transaction_dispatcher_host_->map_, transaction_id);
   if (!idb_transaction || !idb_object_store)
     return;
 
   *ec = 0;
   scoped_ptr<WebIDBCallbacks> callbacks(
       new IndexedDBCallbacks<WebSerializedScriptValue>(parent_, thread_id,
                                                        response_id));
   idb_object_store->get(key, callbacks.release(), *idb_transaction, *ec);
 }
 
 void IndexedDBDispatcherHost::ObjectStoreDispatcherHost::OnPut(
     const IndexedDBHostMsg_ObjectStorePut_Params& params,
     WebKit::WebExceptionCode* ec) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   WebIDBObjectStore* idb_object_store = parent_->GetOrTerminateProcess(
       &map_, params.idb_object_store_id);
   WebIDBTransaction* idb_transaction = parent_->GetOrTerminateProcess(
       &parent_->transaction_dispatcher_host_->map_, params.transaction_id);
   if (!idb_transaction || !idb_object_store)
     return;
 
   *ec = 0;
   scoped_ptr<WebIDBCallbacks> callbacks(
       new IndexedDBCallbacks<WebIDBKey>(parent_, params.thread_id,
                                         params.response_id));
   idb_object_store->put(params.serialized_value, params.key, params.put_mode,
                         callbacks.release(), *idb_transaction, *ec);
   if (*ec)
     return;
   int64 size = UTF16ToUTF8(params.serialized_value.data()).size();
   WebIDBTransactionIDToSizeMap* map =
       &parent_->transaction_dispatcher_host_->transaction_size_map_;
   (*map)[params.transaction_id] += size;
 }
 
 void IndexedDBDispatcherHost::ObjectStoreDispatcherHost::OnDelete(
     int idb_object_store_id,
     int32 thread_id,
     int32 response_id,
     const IndexedDBKey& key,
     int32 transaction_id,
     WebKit::WebExceptionCode* ec) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   WebIDBObjectStore* idb_object_store = parent_->GetOrTerminateProcess(
       &map_, idb_object_store_id);
   WebIDBTransaction* idb_transaction = parent_->GetOrTerminateProcess(
       &parent_->transaction_dispatcher_host_->map_, transaction_id);
   if (!idb_transaction || !idb_object_store)
     return;
 
   *ec = 0;
   scoped_ptr<WebIDBCallbacks> callbacks(
       new IndexedDBCallbacks<WebSerializedScriptValue>(parent_, thread_id,
                                                        response_id));
   idb_object_store->deleteFunction(
       key, callbacks.release(), *idb_transaction, *ec);
 }
 
 void IndexedDBDispatcherHost::ObjectStoreDispatcherHost::OnClear(
     int idb_object_store_id,
     int32 thread_id,
     int32 response_id,
     int32 transaction_id,
     WebKit::WebExceptionCode* ec) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   WebIDBObjectStore* idb_object_store = parent_->GetOrTerminateProcess(
       &map_, idb_object_store_id);
   WebIDBTransaction* idb_transaction = parent_->GetOrTerminateProcess(
       &parent_->transaction_dispatcher_host_->map_, transaction_id);
   if (!idb_transaction || !idb_object_store)
     return;
 
   *ec = 0;
   scoped_ptr<WebIDBCallbacks> callbacks(
       new IndexedDBCallbacks<WebSerializedScriptValue>(parent_, thread_id,
                                                        response_id));
   idb_object_store->clear(callbacks.release(), *idb_transaction, *ec);
 }
 
 void IndexedDBDispatcherHost::ObjectStoreDispatcherHost::OnCreateIndex(
    const IndexedDBHostMsg_ObjectStoreCreateIndex_Params& params,
    int32* index_id, WebKit::WebExceptionCode* ec) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   WebIDBObjectStore* idb_object_store = parent_->GetOrTerminateProcess(
       &map_, params.idb_object_store_id);
   WebIDBTransaction* idb_transaction = parent_->GetOrTerminateProcess(
       &parent_->transaction_dispatcher_host_->map_, params.transaction_id);
   if (!idb_object_store || !idb_transaction)
     return;
 
   *ec = 0;
   WebIDBIndex* index = idb_object_store->createIndex(
       params.name, params.key_path, params.unique, params.multi_entry,
@@ skipping 20 matching lines @@
   *ec = 0;
   WebIDBIndex* index = idb_object_store->index(name, *ec);
   *idb_index_id = parent_->Add(index);
 }
 
 void IndexedDBDispatcherHost::ObjectStoreDispatcherHost::OnDeleteIndex(
     int32 idb_object_store_id,
     const string16& name,
     int32 transaction_id,
     WebKit::WebExceptionCode* ec) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   WebIDBObjectStore* idb_object_store = parent_->GetOrTerminateProcess(
       &map_, idb_object_store_id);
   WebIDBTransaction* idb_transaction = parent_->GetOrTerminateProcess(
       &parent_->transaction_dispatcher_host_->map_, transaction_id);
   if (!idb_object_store || !idb_transaction)
     return;
 
   *ec = 0;
   idb_object_store->deleteIndex(name, *idb_transaction, *ec);
 }
 
 void IndexedDBDispatcherHost::ObjectStoreDispatcherHost::OnOpenCursor(
     const IndexedDBHostMsg_ObjectStoreOpenCursor_Params& params,
     WebKit::WebExceptionCode* ec) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   WebIDBObjectStore* idb_object_store = parent_->GetOrTerminateProcess(
       &parent_->object_store_dispatcher_host_->map_,
       params.idb_object_store_id);
   WebIDBTransaction* idb_transaction = parent_->GetOrTerminateProcess(
       &parent_->transaction_dispatcher_host_->map_, params.transaction_id);
   if (!idb_transaction || !idb_object_store)
     return;
 
   *ec = 0;
   scoped_ptr<WebIDBCallbacks> callbacks(
       new IndexedDBCallbacks<WebIDBCursor>(parent_, params.thread_id,
                                            params.response_id, -1));
   idb_object_store->openCursor(
       WebIDBKeyRange(params.lower_key, params.upper_key, params.lower_open,
                      params.upper_open),
       params.direction, callbacks.release(), *idb_transaction, *ec);
 }
 
 void IndexedDBDispatcherHost::ObjectStoreDispatcherHost::OnCount(
     const IndexedDBHostMsg_ObjectStoreCount_Params& params,
     WebKit::WebExceptionCode* ec) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   WebIDBObjectStore* idb_object_store = parent_->GetOrTerminateProcess(
       &parent_->object_store_dispatcher_host_->map_,
       params.idb_object_store_id);
   WebIDBTransaction* idb_transaction = parent_->GetOrTerminateProcess(
       &parent_->transaction_dispatcher_host_->map_, params.transaction_id);
   if (!idb_transaction || !idb_object_store)
     return;
 
   *ec = 0;
   scoped_ptr<WebIDBCallbacks> callbacks(
@@ skipping 83 matching lines @@
 
   *script_value = content::SerializedScriptValue(idb_cursor->value());
 }
 
 void IndexedDBDispatcherHost::CursorDispatcherHost::OnUpdate(
     int32 cursor_id,
     int32 thread_id,
     int32 response_id,
     const content::SerializedScriptValue& value,
     WebKit::WebExceptionCode* ec) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   WebIDBCursor* idb_cursor = parent_->GetOrTerminateProcess(&map_, cursor_id);
   if (!idb_cursor)
     return;
 
   *ec = 0;
   idb_cursor->update(
       value, new IndexedDBCallbacks<WebIDBKey>(parent_, thread_id, response_id),
       *ec);
 }
 
 void IndexedDBDispatcherHost::CursorDispatcherHost::OnContinue(
     int32 cursor_id,
     int32 thread_id,
     int32 response_id,
     const IndexedDBKey& key,
     WebKit::WebExceptionCode* ec) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   WebIDBCursor* idb_cursor = parent_->GetOrTerminateProcess(&map_, cursor_id);
   if (!idb_cursor)
     return;
 
   *ec = 0;
   idb_cursor->continueFunction(
       key, new IndexedDBCallbacks<WebIDBCursor>(parent_, thread_id, response_id,
                                                 cursor_id), *ec);
 }
 
 void IndexedDBDispatcherHost::CursorDispatcherHost::OnPrefetch(
     int32 cursor_id,
     int32 thread_id,
     int32 response_id,
     int n,
     WebKit::WebExceptionCode* ec) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   WebIDBCursor* idb_cursor = parent_->GetOrTerminateProcess(&map_, cursor_id);
   if (!idb_cursor)
     return;
 
   *ec = 0;
   idb_cursor->prefetchContinue(
       n, new IndexedDBCallbacks<WebIDBCursor>(parent_, thread_id, response_id,
                                               cursor_id), *ec);
 }
 
 void IndexedDBDispatcherHost::CursorDispatcherHost::OnPrefetchReset(
     int32 cursor_id, int used_prefetches, int unused_prefetches) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   WebIDBCursor* idb_cursor = parent_->GetOrTerminateProcess(&map_, cursor_id);
   if (!idb_cursor)
     return;
 
   idb_cursor->prefetchReset(used_prefetches, unused_prefetches);
 }
 
 void IndexedDBDispatcherHost::CursorDispatcherHost::OnDelete(
     int32 cursor_id,
     int32 thread_id,
     int32 response_id,
     WebKit::WebExceptionCode* ec) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   WebIDBCursor* idb_cursor = parent_->GetOrTerminateProcess(&map_, cursor_id);
   if (!idb_cursor)
     return;
 
   *ec = 0;
   idb_cursor->deleteFunction(
       new IndexedDBCallbacks<WebSerializedScriptValue>(parent_, thread_id,
                                                        response_id), *ec);
 }
 
@@ skipping 71 matching lines @@
   if (!idb_transaction)
     return;
 
   *ec = 0;
   WebIDBObjectStore* object_store = idb_transaction->objectStore(name, *ec);
   *object_store_id = object_store ? parent_->Add(object_store) : 0;
 }
 
 void IndexedDBDispatcherHost::
     TransactionDispatcherHost::OnDidCompleteTaskEvents(int transaction_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   WebIDBTransaction* idb_transaction = parent_->GetOrTerminateProcess(
       &map_, transaction_id);
   if (!idb_transaction)
     return;
 
   // TODO(dgrogan): Tell the page the transaction aborted because of quota.
   if (parent_->Context()->WouldBeOverQuota(
       transaction_url_map_[transaction_id],
       transaction_size_map_[transaction_id])) {
     idb_transaction->abort();
     return;
   }
   idb_transaction->didCompleteTaskEvents();
 }
 
 void IndexedDBDispatcherHost::TransactionDispatcherHost::OnDestroyed(
     int32 object_id) {
   transaction_size_map_.erase(object_id);
   transaction_url_map_.erase(object_id);
   parent_->DestroyObject(&map_, object_id);
 }