Revert 56862 - Add transaction coordinator. Allow idle transactions to be abo...

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 "chrome/browser/chrome_thread.h"
 #include "chrome/browser/in_process_webkit/indexed_db_callbacks.h"
 #include "chrome/browser/renderer_host/browser_render_process_host.h"
 #include "chrome/browser/renderer_host/resource_message_filter.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/serialized_script_value.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebDOMStringList.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebIDBCursor.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebIDBDatabase.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebIDBDatabaseError.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebIDBKeyRange.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebIDBIndex.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebIDBFactory.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebIDBObjectStore.h"
-#include "third_party/WebKit/WebKit/chromium/public/WebIDBTransaction.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebSecurityOrigin.h"
-#include "third_party/WebKit/WebKit/chromium/public/WebVector.h"
 
 using WebKit::WebDOMStringList;
 using WebKit::WebIDBCursor;
 using WebKit::WebIDBDatabase;
 using WebKit::WebIDBDatabaseError;
 using WebKit::WebIDBIndex;
 using WebKit::WebIDBKey;
 using WebKit::WebIDBKeyRange;
 using WebKit::WebIDBObjectStore;
-using WebKit::WebIDBTransaction;
 using WebKit::WebSecurityOrigin;
 using WebKit::WebSerializedScriptValue;
-using WebKit::WebVector;
 
 IndexedDBDispatcherHost::IndexedDBDispatcherHost(
     IPC::Message::Sender* sender, WebKitContext* webkit_context)
     : sender_(sender),
       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_handle_(0) {
   DCHECK(sender_);
   DCHECK(webkit_context_.get());
 }
 
 IndexedDBDispatcherHost::~IndexedDBDispatcherHost() {
 }
 
 void IndexedDBDispatcherHost::Init(int process_id,
                                    base::ProcessHandle process_handle) {
@@ skipping 27 matching lines @@
 bool IndexedDBDispatcherHost::OnMessageReceived(const IPC::Message& message) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   DCHECK(process_handle_);
 
   switch (message.type()) {
     case ViewHostMsg_IDBCursorDestroyed::ID:
     case ViewHostMsg_IDBCursorDirection::ID:
     case ViewHostMsg_IDBCursorKey::ID:
     case ViewHostMsg_IDBCursorValue::ID:
     case ViewHostMsg_IDBFactoryOpen::ID:
-    case ViewHostMsg_IDBFactoryAbortPendingTransactions::ID:
     case ViewHostMsg_IDBDatabaseName::ID:
     case ViewHostMsg_IDBDatabaseDescription::ID:
     case ViewHostMsg_IDBDatabaseVersion::ID:
     case ViewHostMsg_IDBDatabaseObjectStores::ID:
     case ViewHostMsg_IDBDatabaseCreateObjectStore::ID:
     case ViewHostMsg_IDBDatabaseObjectStore::ID:
     case ViewHostMsg_IDBDatabaseRemoveObjectStore::ID:
-    case ViewHostMsg_IDBDatabaseTransaction::ID:
     case ViewHostMsg_IDBDatabaseDestroyed::ID:
     case ViewHostMsg_IDBIndexName::ID:
     case ViewHostMsg_IDBIndexKeyPath::ID:
     case ViewHostMsg_IDBIndexUnique::ID:
     case ViewHostMsg_IDBIndexDestroyed::ID:
     case ViewHostMsg_IDBObjectStoreName::ID:
     case ViewHostMsg_IDBObjectStoreKeyPath::ID:
     case ViewHostMsg_IDBObjectStoreIndexNames::ID:
     case ViewHostMsg_IDBObjectStoreGet::ID:
     case ViewHostMsg_IDBObjectStoreOpenCursor::ID:
     case ViewHostMsg_IDBObjectStorePut::ID:
     case ViewHostMsg_IDBObjectStoreRemove::ID:
     case ViewHostMsg_IDBObjectStoreCreateIndex::ID:
     case ViewHostMsg_IDBObjectStoreIndex::ID:
     case ViewHostMsg_IDBObjectStoreRemoveIndex::ID:
     case ViewHostMsg_IDBObjectStoreDestroyed::ID:
-    case ViewHostMsg_IDBTransactionDestroyed::ID:
       break;
     default:
       return false;
   }
 
   bool success = ChromeThread::PostTask(
       ChromeThread::WEBKIT, FROM_HERE, NewRunnableMethod(
           this, &IndexedDBDispatcherHost::OnMessageReceivedWebKit, message));
   DCHECK(success);
   return true;
@@ skipping 24 matching lines @@
 void IndexedDBDispatcherHost::OnMessageReceivedWebKit(
     const IPC::Message& message) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
   DCHECK(process_handle_);
 
   bool msg_is_ok = true;
   bool handled =
       database_dispatcher_host_->OnMessageReceived(message, &msg_is_ok) ||
       index_dispatcher_host_->OnMessageReceived(message, &msg_is_ok) ||
       object_store_dispatcher_host_->OnMessageReceived(message, &msg_is_ok) ||
-      cursor_dispatcher_host_->OnMessageReceived(message, &msg_is_ok) ||
-      transaction_dispatcher_host_->OnMessageReceived(message, &msg_is_ok);
+      cursor_dispatcher_host_->OnMessageReceived(message, &msg_is_ok);
 
   if (!handled) {
     handled = true;
     DCHECK(msg_is_ok);
     IPC_BEGIN_MESSAGE_MAP_EX(IndexedDBDispatcherHost, message, msg_is_ok)
       IPC_MESSAGE_HANDLER(ViewHostMsg_IDBFactoryOpen,
                           OnIDBFactoryOpen)
-      IPC_MESSAGE_HANDLER(ViewHostMsg_IDBFactoryAbortPendingTransactions,
-                          OnIDBFactoryAbortPendingTransactions)
       IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
   }
 
   DCHECK(handled);
   if (!msg_is_ok) {
     BrowserRenderProcessHost::BadMessageTerminateProcess(message.type(),
                                                          process_handle_);
   }
 }
 
 int32 IndexedDBDispatcherHost::Add(WebIDBCursor* idb_cursor) {
   return cursor_dispatcher_host_->map_.Add(idb_cursor);
 }
 
 int32 IndexedDBDispatcherHost::Add(WebIDBDatabase* idb_database) {
   return database_dispatcher_host_->map_.Add(idb_database);
 }
 
 int32 IndexedDBDispatcherHost::Add(WebIDBIndex* idb_index) {
   return index_dispatcher_host_->map_.Add(idb_index);
 }
 
 int32 IndexedDBDispatcherHost::Add(WebIDBObjectStore* idb_object_store) {
   return object_store_dispatcher_host_->map_.Add(idb_object_store);
 }
 
-void IndexedDBDispatcherHost::Add(WebIDBTransaction* idb_transaction) {
-  transaction_dispatcher_host_->map_.AddWithID(
-      idb_transaction, idb_transaction->id());
-}
-
 void IndexedDBDispatcherHost::OnIDBFactoryOpen(
     const ViewHostMsg_IDBFactoryOpen_Params& params) {
   // TODO(jorlow): Check the content settings map and use params.routing_id_
   //               if it's necessary to ask the user for permission.
 
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
   Context()->GetIDBFactory()->open(
       params.name_, params.description_,
       new IndexedDBCallbacks<WebIDBDatabase>(this, params.response_id_),
       WebSecurityOrigin::createFromDatabaseIdentifier(params.origin_), NULL);
 }
 
-void IndexedDBDispatcherHost::OnIDBFactoryAbortPendingTransactions(
-    const std::vector<int32>& ids) {
-  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
-
-  WebVector<int32> pendingIDs = ids;
-  Context()->GetIDBFactory()->abortPendingTransactions(pendingIDs);
-}
-
 //////////////////////////////////////////////////////////////////////
 // Helper templates.
 //
 
 template <typename ObjectType>
 ObjectType* IndexedDBDispatcherHost::GetOrTerminateProcess(
     IDMap<ObjectType, IDMapOwnPointer>* map, int32 return_object_id,
     IPC::Message* reply_msg, uint32 message_type) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
   ObjectType* return_object = map->Lookup(return_object_id);
@@ skipping 51 matching lines @@
                                     OnDescription)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_IDBDatabaseVersion, OnVersion)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_IDBDatabaseObjectStores,
                                     OnObjectStores)
     IPC_MESSAGE_HANDLER(ViewHostMsg_IDBDatabaseCreateObjectStore,
                         OnCreateObjectStore)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_IDBDatabaseObjectStore,
                                     OnObjectStore)
     IPC_MESSAGE_HANDLER(ViewHostMsg_IDBDatabaseRemoveObjectStore,
                         OnRemoveObjectStore)
-    IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_IDBDatabaseTransaction,
-                                    OnTransaction)
     IPC_MESSAGE_HANDLER(ViewHostMsg_IDBDatabaseDestroyed, OnDestroyed)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::Send(
     IPC::Message* message) {
   // The macro magic in OnMessageReceived requires this to link, but it should
   // never actually be called.
@@ skipping 71 matching lines @@
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
   WebIDBDatabase* idb_database = parent_->GetOrTerminateProcess(
       &map_, idb_database_id, NULL,
       ViewHostMsg_IDBDatabaseRemoveObjectStore::ID);
   if (!idb_database)
     return;
   idb_database->removeObjectStore(
       name, new IndexedDBCallbacks<WebIDBObjectStore>(parent_, response_id));
 }
 
-void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnTransaction(
-    int32 idb_database_id, const std::vector<string16>& names,
-    int32 mode, int32 timeout, IPC::Message* reply_msg) {
-  WebIDBDatabase* database = parent_->GetOrTerminateProcess(
-      &map_, idb_database_id, reply_msg,
-      ViewHostMsg_IDBDatabaseTransaction::ID);
-  if (!database)
-      return;
-
-  WebDOMStringList object_stores;
-  for (std::vector<string16>::const_iterator it = names.begin();
-       it != names.end(); ++it) {
-    object_stores.append(*it);
-  }
-
-  WebIDBTransaction* transaction = database->transaction(
-      object_stores, mode, timeout);
-  transaction->setCallbacks(
-      new IndexedDBTransactionCallbacks(parent_, transaction->id()));
-  parent_->Add(transaction);
-  ViewHostMsg_IDBDatabaseTransaction::WriteReplyParams(
-      reply_msg, transaction->id());
-  parent_->Send(reply_msg);
-}
-
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnDestroyed(
     int32 object_id) {
   parent_->DestroyObject(&map_, object_id,
                          ViewHostMsg_IDBDatabaseDestroyed::ID);
 }
 
 
 //////////////////////////////////////////////////////////////////////
 // IndexedDBDispatcherHost::IndexDispatcherHost
 //
@@ skipping 227 matching lines @@
     IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_IDBCursorDirection,
                                     OnDirection)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_IDBCursorKey, OnKey)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_IDBCursorValue, OnValue)
     IPC_MESSAGE_HANDLER(ViewHostMsg_IDBCursorDestroyed, OnDestroyed)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
-
 void IndexedDBDispatcherHost::CursorDispatcherHost::Send(
     IPC::Message* message) {
   // The macro magic in OnMessageReceived requires this to link, but it should
   // never actually be called.
   NOTREACHED();
   parent_->Send(message);
 }
 
 void IndexedDBDispatcherHost::CursorDispatcherHost::OnOpenCursor(
     const ViewHostMsg_IDBObjectStoreOpenCursor_Params& params) {
@@ skipping 47 matching lines @@
   SerializedScriptValue value(idb_cursor->value());
   ViewHostMsg_IDBCursorValue::WriteReplyParams(reply_msg, value);
   parent_->Send(reply_msg);
 }
 
 void IndexedDBDispatcherHost::CursorDispatcherHost::OnDestroyed(
     int32 object_id) {
   parent_->DestroyObject(
       &map_, object_id, ViewHostMsg_IDBCursorDestroyed::ID);
 }
-
-//////////////////////////////////////////////////////////////////////
-// IndexedDBDispatcherHost::TransactionDispatcherHost
-//
-
-IndexedDBDispatcherHost::TransactionDispatcherHost::TransactionDispatcherHost(
-    IndexedDBDispatcherHost* parent)
-    : parent_(parent) {
-}
-
-IndexedDBDispatcherHost::
-    TransactionDispatcherHost::~TransactionDispatcherHost() {
-}
-
-bool IndexedDBDispatcherHost::TransactionDispatcherHost::OnMessageReceived(
-    const IPC::Message& message, bool* msg_is_ok) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP_EX(IndexedDBDispatcherHost::TransactionDispatcherHost,
-                           message, *msg_is_ok)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_IDBTransactionDestroyed, OnDestroyed)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-  return handled;
-}
-
-void IndexedDBDispatcherHost::TransactionDispatcherHost::Send(
-    IPC::Message* message) {
-  // The macro magic in OnMessageReceived requires this to link, but it should
-  // never actually be called.
-  NOTREACHED();
-  parent_->Send(message);
-}
-
-void IndexedDBDispatcherHost::TransactionDispatcherHost::OnDestroyed(
-    int32 object_id) {
-  parent_->DestroyObject(
-      &map_, object_id, ViewHostMsg_IDBTransactionDestroyed::ID);
-}