Fix problems from my change to IndexedDBDispatcherHost.

chrome/browser/in_process_webkit/indexed_db_dispatcher_host.cc

 // Copyright (c) 2010 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 "chrome/browser/in_process_webkit/indexed_db_dispatcher_host.h"
 
 #include "base/command_line.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
@@ skipping 62 matching lines @@
       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();
   BrowserThread::DeleteSoon(
         BrowserThread::WEBKIT, FROM_HERE, database_dispatcher_host_.release());
   BrowserThread::DeleteSoon(
         BrowserThread::WEBKIT, FROM_HERE, index_dispatcher_host_.release());
   BrowserThread::DeleteSoon(
         BrowserThread::WEBKIT, FROM_HERE,
         object_store_dispatcher_host_.release());
   BrowserThread::DeleteSoon(
         BrowserThread::WEBKIT, FROM_HERE, cursor_dispatcher_host_.release());
   BrowserThread::DeleteSoon(
@@ skipping 215 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
   WebIDBDatabase* idb_database = parent_->GetOrTerminateProcess(
       &map_, params.idb_database_id,
       IndexedDBHostMsg_DatabaseCreateObjectStore::ID);
   WebIDBTransaction* idb_transaction = parent_->GetOrTerminateProcess(
       &parent_->transaction_dispatcher_host_->map_, params.transaction_id,
       IndexedDBHostMsg_DatabaseCreateObjectStore::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);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnDeleteObjectStore(
     int32 idb_database_id,
     const string16& name,
     int32 transaction_id,
     WebKit::WebExceptionCode* ec) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
   WebIDBDatabase* idb_database = parent_->GetOrTerminateProcess(
       &map_, idb_database_id, IndexedDBHostMsg_DatabaseDeleteObjectStore::ID);
   WebIDBTransaction* idb_transaction = parent_->GetOrTerminateProcess(
       &parent_->transaction_dispatcher_host_->map_, transaction_id,
       IndexedDBHostMsg_DatabaseDeleteObjectStore::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 response_id,
     const string16& version,
     WebKit::WebExceptionCode* ec) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
   WebIDBDatabase* idb_database = parent_->GetOrTerminateProcess(
       &map_, idb_database_id, IndexedDBHostMsg_DatabaseSetVersion::ID);
   if (!idb_database)
     return;
 
+  *ec = 0;
   idb_database->setVersion(
       version,
       new IndexedDBCallbacks<WebIDBTransaction>(parent_, response_id),
       *ec);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnTransaction(
     int32 idb_database_id,
     const std::vector<string16>& names,
     int32 mode,
     int32 timeout,
     int32* idb_transaction_id,
     WebKit::WebExceptionCode* ec) {
   WebIDBDatabase* database = parent_->GetOrTerminateProcess(
       &map_, idb_database_id, IndexedDBHostMsg_DatabaseTransaction::ID);
   if (!database)
       return;
 
   WebDOMStringList object_stores;
   for (std::vector<string16>::const_iterator it = names.begin();
        it != names.end(); ++it) {
     object_stores.append(*it);
   }
 
+  *ec = 0;
   WebIDBTransaction* transaction = database->transaction(
       object_stores, mode, timeout, *ec);
   DCHECK(!transaction != !*ec);
   *idb_transaction_id = *ec ? 0 : parent_->Add(transaction);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnDestroyed(
     int32 object_id) {
   parent_->DestroyObject(&map_, object_id,
                          IndexedDBHostMsg_DatabaseDestroyed::ID);
@@ skipping 67 matching lines @@
     WebKit::WebExceptionCode* ec) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
   WebIDBIndex* idb_index = parent_->GetOrTerminateProcess(
       &map_, params.idb_index_id, IndexedDBHostMsg_IndexOpenObjectCursor::ID);
   WebIDBTransaction* idb_transaction = parent_->GetOrTerminateProcess(
       &parent_->transaction_dispatcher_host_->map_,
       params.transaction_id, IndexedDBHostMsg_IndexOpenObjectCursor::ID);
   if (!idb_transaction || !idb_index)
     return;
 
+  *ec = 0;
   scoped_ptr<WebIDBCallbacks> callbacks(
       new IndexedDBCallbacks<WebIDBCursor>(parent_, params.response_id));
   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));
   WebIDBIndex* idb_index = parent_->GetOrTerminateProcess(
       &map_, params.idb_index_id, IndexedDBHostMsg_IndexOpenKeyCursor::ID);
   WebIDBTransaction* idb_transaction = parent_->GetOrTerminateProcess(
       &parent_->transaction_dispatcher_host_->map_, params.transaction_id,
       IndexedDBHostMsg_IndexOpenKeyCursor::ID);
   if (!idb_transaction || !idb_index)
     return;
 
+  *ec = 0;
   scoped_ptr<WebIDBCallbacks> callbacks(
       new IndexedDBCallbacks<WebIDBCursor>(parent_, params.response_id));
   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::OnGetObject(
     int idb_index_id,
     int32 response_id,
     const IndexedDBKey& key,
     int32 transaction_id,
     WebKit::WebExceptionCode* ec) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
   WebIDBIndex* idb_index = parent_->GetOrTerminateProcess(
       &map_, idb_index_id, IndexedDBHostMsg_IndexGetObject::ID);
   WebIDBTransaction* idb_transaction = parent_->GetOrTerminateProcess(
       &parent_->transaction_dispatcher_host_->map_, transaction_id,
       IndexedDBHostMsg_IndexGetObject::ID);
   if (!idb_transaction || !idb_index)
     return;
 
+  *ec = 0;
   scoped_ptr<WebIDBCallbacks> callbacks(
       new IndexedDBCallbacks<WebSerializedScriptValue>(parent_, response_id));
   idb_index->getObject(key, callbacks.release(), *idb_transaction, *ec);
 }
 
 void IndexedDBDispatcherHost::IndexDispatcherHost::OnGetKey(
     int idb_index_id,
     int32 response_id,
     const IndexedDBKey& key,
     int32 transaction_id,
     WebKit::WebExceptionCode* ec) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
   WebIDBIndex* idb_index = parent_->GetOrTerminateProcess(
       &map_, idb_index_id, IndexedDBHostMsg_IndexGetKey::ID);
   WebIDBTransaction* idb_transaction = parent_->GetOrTerminateProcess(
       &parent_->transaction_dispatcher_host_->map_, transaction_id,
       IndexedDBHostMsg_IndexGetKey::ID);
   if (!idb_transaction || !idb_index)
     return;
 
+  *ec = 0;
   scoped_ptr<WebIDBCallbacks> callbacks(
       new IndexedDBCallbacks<WebIDBKey>(parent_, response_id));
   idb_index->getKey(key, callbacks.release(), *idb_transaction, *ec);
 }
 
 void IndexedDBDispatcherHost::IndexDispatcherHost::OnDestroyed(
     int32 object_id) {
   parent_->DestroyObject(&map_, object_id, IndexedDBHostMsg_IndexDestroyed::ID);
 }
 
@@ skipping 70 matching lines @@
     WebKit::WebExceptionCode* ec) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
   WebIDBObjectStore* idb_object_store = parent_->GetOrTerminateProcess(
       &map_, idb_object_store_id, IndexedDBHostMsg_ObjectStoreGet::ID);
   WebIDBTransaction* idb_transaction = parent_->GetOrTerminateProcess(
       &parent_->transaction_dispatcher_host_->map_, transaction_id,
       IndexedDBHostMsg_ObjectStoreGet::ID);
   if (!idb_transaction || !idb_object_store)
     return;
 
+  *ec = 0;
   scoped_ptr<WebIDBCallbacks> callbacks(
       new IndexedDBCallbacks<WebSerializedScriptValue>(parent_, 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));
   WebIDBObjectStore* idb_object_store = parent_->GetOrTerminateProcess(
       &map_, params.idb_object_store_id, IndexedDBHostMsg_ObjectStorePut::ID);
   WebIDBTransaction* idb_transaction = parent_->GetOrTerminateProcess(
       &parent_->transaction_dispatcher_host_->map_, params.transaction_id,
       IndexedDBHostMsg_ObjectStorePut::ID);
   if (!idb_transaction || !idb_object_store)
     return;
 
+  *ec = 0;
   scoped_ptr<WebIDBCallbacks> callbacks(
       new IndexedDBCallbacks<WebIDBKey>(parent_, params.response_id));
   idb_object_store->put(params.serialized_value, params.key, params.add_only,
                         callbacks.release(), *idb_transaction, *ec);
 }
 
 void IndexedDBDispatcherHost::ObjectStoreDispatcherHost::OnDelete(
     int idb_object_store_id,
     int32 response_id,
     const IndexedDBKey& key,
     int32 transaction_id,
     WebKit::WebExceptionCode* ec) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
   WebIDBObjectStore* idb_object_store = parent_->GetOrTerminateProcess(
       &map_, idb_object_store_id, IndexedDBHostMsg_ObjectStoreDelete::ID);
   WebIDBTransaction* idb_transaction = parent_->GetOrTerminateProcess(
       &parent_->transaction_dispatcher_host_->map_, transaction_id,
       IndexedDBHostMsg_ObjectStoreDelete::ID);
   if (!idb_transaction || !idb_object_store)
     return;
 
+  *ec = 0;
   scoped_ptr<WebIDBCallbacks> callbacks(
       new IndexedDBCallbacks<void>(parent_, response_id));
   idb_object_store->deleteFunction(
       key, 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));
   WebIDBObjectStore* idb_object_store = parent_->GetOrTerminateProcess(
       &map_, params.idb_object_store_id,
       IndexedDBHostMsg_ObjectStoreCreateIndex::ID);
   WebIDBTransaction* idb_transaction = parent_->GetOrTerminateProcess(
       &parent_->transaction_dispatcher_host_->map_, params.transaction_id,
       IndexedDBHostMsg_ObjectStoreCreateIndex::ID);
   if (!idb_object_store || !idb_transaction)
     return;
 
+  *ec = 0;
   WebIDBIndex* index = idb_object_store->createIndex(
       params.name, params.key_path, params.unique, *idb_transaction, *ec);
   *index_id = *ec ? 0 : parent_->Add(index);
 }
 
 void IndexedDBDispatcherHost::ObjectStoreDispatcherHost::OnIndex(
     int32 idb_object_store_id,
     const string16& name,
     int32* idb_index_id,
     WebKit::WebExceptionCode* ec) {
   WebIDBObjectStore* idb_object_store = parent_->GetOrTerminateProcess(
       &map_, idb_object_store_id, IndexedDBHostMsg_ObjectStoreIndex::ID);
   if (!idb_object_store)
     return;
 
+  *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));
   WebIDBObjectStore* idb_object_store = parent_->GetOrTerminateProcess(
       &map_, idb_object_store_id, IndexedDBHostMsg_ObjectStoreDeleteIndex::ID);
   WebIDBTransaction* idb_transaction = parent_->GetOrTerminateProcess(
       &parent_->transaction_dispatcher_host_->map_, transaction_id,
       IndexedDBHostMsg_ObjectStoreDeleteIndex::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));
   WebIDBObjectStore* idb_object_store = parent_->GetOrTerminateProcess(
       &parent_->object_store_dispatcher_host_->map_,
       params.idb_object_store_id, IndexedDBHostMsg_ObjectStoreOpenCursor::ID);
   WebIDBTransaction* idb_transaction = parent_->GetOrTerminateProcess(
       &parent_->transaction_dispatcher_host_->map_, params.transaction_id,
       IndexedDBHostMsg_ObjectStoreOpenCursor::ID);
   if (!idb_transaction || !idb_object_store)
     return;
 
+  *ec = 0;
   scoped_ptr<WebIDBCallbacks> callbacks(
       new IndexedDBCallbacks<WebIDBCursor>(parent_, params.response_id));
   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::OnDestroyed(
     int32 object_id) {
@@ skipping 78 matching lines @@
     int32 cursor_id,
     int32 response_id,
     const SerializedScriptValue& value,
     WebKit::WebExceptionCode* ec) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
   WebIDBCursor* idb_cursor = parent_->GetOrTerminateProcess(
       &map_, cursor_id, IndexedDBHostMsg_CursorUpdate::ID);
   if (!idb_cursor)
     return;
 
+  *ec = 0;
   idb_cursor->update(
       value, new IndexedDBCallbacks<void>(parent_, response_id), *ec);
 }
 
 void IndexedDBDispatcherHost::CursorDispatcherHost::OnContinue(
     int32 cursor_id,
     int32 response_id,
     const IndexedDBKey& key,
     WebKit::WebExceptionCode* ec) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
   WebIDBCursor* idb_cursor = parent_->GetOrTerminateProcess(
       &map_, cursor_id, IndexedDBHostMsg_CursorContinue::ID);
   if (!idb_cursor)
     return;
 
+  *ec = 0;
   idb_cursor->continueFunction(
       key, new IndexedDBCallbacks<WebIDBCursor>(parent_, response_id), *ec);
 }
 
 void IndexedDBDispatcherHost::CursorDispatcherHost::OnDelete(
     int32 cursor_id,
     int32 response_id,
     WebKit::WebExceptionCode* ec) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
   WebIDBCursor* idb_cursor = parent_->GetOrTerminateProcess(
       &map_, cursor_id, IndexedDBHostMsg_CursorUpdate::ID);
   if (!idb_cursor)
     return;
 
+  *ec = 0;
   // TODO(jorlow): This should be delete.
   idb_cursor->remove(new IndexedDBCallbacks<void>(parent_, response_id), *ec);
 }
 
 void IndexedDBDispatcherHost::CursorDispatcherHost::OnDestroyed(
     int32 object_id) {
   parent_->DestroyObject(
       &map_, object_id, IndexedDBHostMsg_CursorDestroyed::ID);
 }
 
@@ skipping 59 matching lines @@
 }
 
 void IndexedDBDispatcherHost::TransactionDispatcherHost::OnObjectStore(
     int32 transaction_id, const string16& name, int32* object_store_id,
     WebKit::WebExceptionCode* ec) {
   WebIDBTransaction* idb_transaction = parent_->GetOrTerminateProcess(
       &map_, transaction_id, IndexedDBHostMsg_TransactionObjectStore::ID);
   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));
   WebIDBTransaction* idb_transaction = parent_->GetOrTerminateProcess(
       &map_, transaction_id,
       IndexedDBHostMsg_TransactionDidCompleteTaskEvents::ID);
   if (!idb_transaction)
     return;
 
   idb_transaction->didCompleteTaskEvents();
 }
 
 void IndexedDBDispatcherHost::TransactionDispatcherHost::OnDestroyed(
     int32 object_id) {
   parent_->DestroyObject(
       &map_, object_id, IndexedDBHostMsg_TransactionDestroyed::ID);
 }