Chrome side changes for integer versions

content/common/indexed_db/indexed_db_dispatcher.cc

 // Copyright (c) 2012 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/common/indexed_db/indexed_db_dispatcher.h"
 
 #include "base/lazy_instance.h"
 #include "base/threading/thread_local.h"
 #include "content/common/child_thread.h"
 #include "content/common/indexed_db/indexed_db_messages.h"
@@ skipping 83 matching lines @@
     IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksSuccessIndexedDBKey,
                         OnSuccessIndexedDBKey)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksSuccessIDBTransaction,
                         OnSuccessIDBTransaction)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksSuccessStringList,
                         OnSuccessStringList)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksSuccessSerializedScriptValue,
                         OnSuccessSerializedScriptValue)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksError, OnError)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksBlocked, OnBlocked)
+    IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksIntBlocked, OnIntBlocked)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_TransactionCallbacksAbort, OnAbort)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_TransactionCallbacksComplete, OnComplete)
+    IPC_MESSAGE_HANDLER(IndexedDBMsg_DatabaseCallbacksIntVersionChange,
+                        OnIntVersionChange)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_DatabaseCallbacksVersionChange,
                         OnVersionChange)
+    IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksUpgradeNeeded, OnUpgradeNeeded)

[jsbell, 2012/07/25 22:12:16]

Can you put this with the other _Callbacks messages?

[dgrogan, 2012/07/25 23:59:59]

Done.

     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   // If a message gets here, IndexedDBMessageFilter already determined that it
   // is an IndexedDB message.
-  DCHECK(handled);
+  DCHECK(handled) << "Didn't handle a message defined at line "
+                  << IPC_MESSAGE_ID_LINE(msg.type());
 }
 
 bool IndexedDBDispatcher::Send(IPC::Message* msg) {
   if (CurrentWorkerId()) {
     scoped_refptr<IPC::SyncMessageFilter> filter(
         ChildThread::current()->sync_message_filter());
     return filter->Send(msg);
   }
   return ChildThread::current()->Send(msg);
 }
@@ skipping 83 matching lines @@
 
   int32 response_id = pending_callbacks_.Add(callbacks.release());
   Send(new IndexedDBHostMsg_CursorDelete(idb_cursor_id, CurrentWorkerId(),
                                          response_id, ec));
   if (*ec)
     pending_callbacks_.Remove(response_id);
 }
 
 void IndexedDBDispatcher::RequestIDBFactoryOpen(
     const string16& name,
+    int64 version,
     WebIDBCallbacks* callbacks_ptr,
     const string16& origin,
     WebFrame* web_frame) {
   ResetCursorPrefetchCaches();
   scoped_ptr<WebIDBCallbacks> callbacks(callbacks_ptr);
 
   if (!CurrentWorkerId() &&
       !ChildThread::current()->IsWebFrameValid(web_frame))
     return;
 
   IndexedDBHostMsg_FactoryOpen_Params params;
   params.thread_id = CurrentWorkerId();
   params.response_id = pending_callbacks_.Add(callbacks.release());
   params.origin = origin;
   params.name = name;
+  params.version = version;
   Send(new IndexedDBHostMsg_FactoryOpen(params));
 }
 
 void IndexedDBDispatcher::RequestIDBFactoryGetDatabaseNames(
     WebIDBCallbacks* callbacks_ptr,
     const string16& origin,
     WebFrame* web_frame) {
   ResetCursorPrefetchCaches();
   scoped_ptr<WebIDBCallbacks> callbacks(callbacks_ptr);
 
@@ skipping 24 matching lines @@
   params.thread_id = CurrentWorkerId();
   params.response_id = pending_callbacks_.Add(callbacks.release());
   params.origin = origin;
   params.name = name;
   Send(new IndexedDBHostMsg_FactoryDeleteDatabase(params));
 }
 
 void IndexedDBDispatcher::RequestIDBDatabaseClose(int32 idb_database_id) {
   ResetCursorPrefetchCaches();
   Send(new IndexedDBHostMsg_DatabaseClose(idb_database_id));
-  pending_database_callbacks_.Remove(idb_database_id);
+  // There won't be pending database callbacks if the transaction was aborted in
+  // the initial upgradeneeded event handler.
+  if (pending_database_callbacks_.Lookup(idb_database_id))
+    pending_database_callbacks_.Remove(idb_database_id);
 }
 
 void IndexedDBDispatcher::RequestIDBDatabaseOpen(
       WebIDBDatabaseCallbacks* callbacks_ptr,
       int32 idb_database_id) {
   ResetCursorPrefetchCaches();
   scoped_ptr<WebIDBDatabaseCallbacks> callbacks(callbacks_ptr);
 
   DCHECK(!pending_database_callbacks_.Lookup(idb_database_id));
   pending_database_callbacks_.AddWithID(callbacks.release(), idb_database_id);
@@ skipping 246 matching lines @@
 void IndexedDBDispatcher::RegisterWebIDBTransactionCallbacks(
     WebIDBTransactionCallbacks* callbacks,
     int32 id) {
   pending_transaction_callbacks_.AddWithID(callbacks, id);
 }
 
 void IndexedDBDispatcher::CursorDestroyed(int32 cursor_id) {
   cursors_.erase(cursor_id);
 }
 
+void IndexedDBDispatcher::DatabaseDestroyed(int32 database_id) {
+  DCHECK_EQ(databases_.count(database_id), 1u);
+  databases_.erase(database_id);
+}
+
 int32 IndexedDBDispatcher::TransactionId(
     const WebIDBTransaction& transaction) {
   const RendererWebIDBTransactionImpl* impl =
       static_cast<const RendererWebIDBTransactionImpl*>(&transaction);
   return impl->id();
 }
 
 void IndexedDBDispatcher::OnSuccessIDBDatabase(int32 thread_id,
                                                int32 response_id,
                                                int32 object_id) {
   DCHECK_EQ(thread_id, CurrentWorkerId());
   WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(response_id);
   if (!callbacks)
     return;
-  callbacks->onSuccess(new RendererWebIDBDatabaseImpl(object_id));
+  if (!databases_.count(object_id))

[jsbell, 2012/07/25 22:12:16]

Add comment here that count will be non-zero if an upgrade was performed.

(I wonder what happens if you retain the IDBDatabase object in script after the
upgradeneeded transaction completes and call close() on it before you get an
onsuccess?)

[dgrogan, 2012/07/25 23:59:59]

Done.
Ugh, good question.  In trying to test this, I put setTimeout(f(){db.close()},
0) at the end of oncomplete but the success event is fired before the function
in setTimeout.

+    databases_[object_id] = new RendererWebIDBDatabaseImpl(object_id);
+  callbacks->onSuccess(databases_[object_id]);
   pending_callbacks_.Remove(response_id);
 }
 
 void IndexedDBDispatcher::OnSuccessIndexedDBKey(
     int32 thread_id,
     int32 response_id,
     const IndexedDBKey& key) {
   DCHECK_EQ(thread_id, CurrentWorkerId());
   WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(response_id);
   if (!callbacks)
@@ skipping 92 matching lines @@
   RendererWebIDBCursorImpl* cursor = cursors_[cursor_id];
   DCHECK(cursor);
   cursor->SetPrefetchData(keys, primary_keys, values);
 
   WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(response_id);
   DCHECK(callbacks);
   cursor->CachedContinue(callbacks);
   pending_callbacks_.Remove(response_id);
 }
 
+void IndexedDBDispatcher::OnIntBlocked(int32 thread_id,
+                                       int32 response_id,
+                                       int64 existing_version) {
+  DCHECK_EQ(thread_id, CurrentWorkerId());
+  WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(response_id);
+  DCHECK(callbacks);
+  callbacks->onBlocked(existing_version);

[jsbell, 2012/07/25 22:12:16]

Will the non-int OnBlocked plumbing be removed before the setVersion API itself
is removed, or will we have these both in parallel for a while? (Wondering if we
should combine these into one IPC message and using a sentinel value for
distinguishing here.)

[dgrogan, 2012/07/25 23:59:59]

Probably both in parallel for a while.

(Wondering if we
Yeah, the messages and handlers are fairly redundant. But I think I'd rather
have the redundancy than logic (if (sentinel)...) that could be suspect if
there's a bug.

+}
+
 void IndexedDBDispatcher::OnBlocked(int32 thread_id, int32 response_id) {
   DCHECK_EQ(thread_id, CurrentWorkerId());
   WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(response_id);
   DCHECK(callbacks);
   callbacks->onBlocked();
 }
 
 void IndexedDBDispatcher::OnError(int32 thread_id, int32 response_id, int code,
                                   const string16& message) {
   DCHECK_EQ(thread_id, CurrentWorkerId());
@@ skipping 17 matching lines @@
 void IndexedDBDispatcher::OnComplete(int32 thread_id, int32 transaction_id) {
   DCHECK_EQ(thread_id, CurrentWorkerId());
   WebIDBTransactionCallbacks* callbacks =
       pending_transaction_callbacks_.Lookup(transaction_id);
   if (!callbacks)
     return;
   callbacks->onComplete();
   pending_transaction_callbacks_.Remove(transaction_id);
 }
 
+void IndexedDBDispatcher::OnIntVersionChange(int32 thread_id,
+                                             int32 database_id,
+                                             int64 old_version,
+                                             int64 new_version) {
+  DCHECK_EQ(thread_id, CurrentWorkerId());
+  WebIDBDatabaseCallbacks* callbacks =
+      pending_database_callbacks_.Lookup(database_id);
+  // callbacks would be NULL if a versionchange event is received after close
+  // has been called.
+  if (!callbacks)
+    return;
+  callbacks->onVersionChange(old_version, new_version);
+}
+
 void IndexedDBDispatcher::OnVersionChange(int32 thread_id,
                                           int32 database_id,
                                           const string16& newVersion) {
   DCHECK_EQ(thread_id, CurrentWorkerId());
   WebIDBDatabaseCallbacks* callbacks =
       pending_database_callbacks_.Lookup(database_id);
   // callbacks would be NULL if a versionchange event is received after close
   // has been called.
   if (!callbacks)
     return;
   callbacks->onVersionChange(newVersion);
 }
 
+void IndexedDBDispatcher::OnUpgradeNeeded(int32 thread_id,
+                                          int32 response_id,
+                                          int32 transaction_id,
+                                          int32 database_id,
+                                          int64 old_version) {
+  DCHECK_EQ(thread_id, CurrentWorkerId());
+  WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(response_id);
+  DCHECK(callbacks);
+  DCHECK(!databases_.count(database_id));
+  databases_[database_id] = new RendererWebIDBDatabaseImpl(database_id);
+  callbacks->onUpgradeNeeded(old_version,
+                             new RendererWebIDBTransactionImpl(transaction_id),
+                             databases_[database_id]);
+}
+
 void IndexedDBDispatcher::ResetCursorPrefetchCaches(int32 exception_cursor_id) {
   typedef std::map<int32, RendererWebIDBCursorImpl*>::iterator Iterator;
   for (Iterator i = cursors_.begin(); i != cursors_.end(); ++i) {
     if (i->first == exception_cursor_id)
       continue;
     i->second->ResetPrefetchCache();
   }
 }