Use builders to convert between WebKit and content IDB types

content/child/indexed_db/indexed_db_dispatcher.cc

 // Copyright 2013 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/child/indexed_db/indexed_db_dispatcher.h"
 
 #include "base/format_macros.h"
 #include "base/lazy_instance.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_local.h"
+#include "content/child/indexed_db/indexed_db_key_builders.h"
 #include "content/child/indexed_db/proxy_webidbcursor_impl.h"
 #include "content/child/indexed_db/proxy_webidbdatabase_impl.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/common/indexed_db/indexed_db_messages.h"
 #include "ipc/ipc_channel.h"
 #include "third_party/WebKit/public/platform/WebIDBDatabaseCallbacks.h"
 #include "third_party/WebKit/public/platform/WebIDBDatabaseError.h"
 #include "third_party/WebKit/public/platform/WebIDBDatabaseException.h"
-#include "third_party/WebKit/public/platform/WebIDBKeyRange.h"
 
 using WebKit::WebData;
 using WebKit::WebIDBCallbacks;
 using WebKit::WebIDBDatabase;
 using WebKit::WebIDBDatabaseCallbacks;
 using WebKit::WebIDBDatabaseError;
 using WebKit::WebIDBKey;
-using WebKit::WebIDBKeyRange;
 using WebKit::WebIDBMetadata;
 using WebKit::WebString;
 using WebKit::WebVector;
 using base::ThreadLocalPointer;
 using webkit_glue::WorkerTaskRunner;
 
 namespace content {
 static base::LazyInstance<ThreadLocalPointer<IndexedDBDispatcher> >::Leaky
     g_idb_dispatcher_tls = LAZY_INSTANCE_INITIALIZER;
 
@@ skipping 55 matching lines @@
       WebVector<WebIDBMetadata::ObjectStore>(idb_metadata.object_stores.size());
 
   for (size_t i = 0; i < idb_metadata.object_stores.size(); ++i) {
     const IndexedDBObjectStoreMetadata& idb_store_metadata =
         idb_metadata.object_stores[i];
     WebIDBMetadata::ObjectStore& web_store_metadata =
         web_metadata.objectStores[i];
 
     web_store_metadata.id = idb_store_metadata.id;
     web_store_metadata.name = idb_store_metadata.name;
-    web_store_metadata.keyPath = idb_store_metadata.keyPath;
+    web_store_metadata.keyPath =
+        WebIDBKeyPathBuilder::Build(idb_store_metadata.keyPath);
     web_store_metadata.autoIncrement = idb_store_metadata.autoIncrement;
     web_store_metadata.maxIndexId = idb_store_metadata.max_index_id;
     web_store_metadata.indexes =
         WebVector<WebIDBMetadata::Index>(idb_store_metadata.indexes.size());
 
     for (size_t j = 0; j < idb_store_metadata.indexes.size(); ++j) {
       const IndexedDBIndexMetadata& idb_index_metadata =
           idb_store_metadata.indexes[j];
       WebIDBMetadata::Index& web_index_metadata = web_store_metadata.indexes[j];
 
       web_index_metadata.id = idb_index_metadata.id;
       web_index_metadata.name = idb_index_metadata.name;
-      web_index_metadata.keyPath = idb_index_metadata.keyPath;
+      web_index_metadata.keyPath =
+          WebIDBKeyPathBuilder::Build(idb_index_metadata.keyPath);
       web_index_metadata.unique = idb_index_metadata.unique;
       web_index_metadata.multiEntry = idb_index_metadata.multiEntry;
     }
   }
 
   return web_metadata;
 }
 
 void IndexedDBDispatcher::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
@@ skipping 225 matching lines @@
 
   COMPILE_ASSERT(sizeof(params.index_ids[0]) == sizeof(index_ids[0]),
                  Cant_copy);
   params.index_ids
       .assign(index_ids.data(), index_ids.data() + index_ids.size());
 
   params.index_keys.resize(index_keys.size());
   for (size_t i = 0; i < index_keys.size(); ++i) {
     params.index_keys[i].resize(index_keys[i].size());
     for (size_t j = 0; j < index_keys[i].size(); ++j) {
-      params.index_keys[i][j] = IndexedDBKey(index_keys[i][j]);
+      params.index_keys[i][j] =
+          IndexedDBKey(IndexedDBKeyBuilder::Build(index_keys[i][j]));
     }
   }
   Send(new IndexedDBHostMsg_DatabasePut(params));
 }
 
 void IndexedDBDispatcher::RequestIDBDatabaseOpenCursor(
     int32 ipc_database_id,
     int64 transaction_id,
     int64 object_store_id,
     int64 index_id,
@@ skipping 93 matching lines @@
   pending_callbacks_.Remove(ipc_callbacks_id);
 }
 
 void IndexedDBDispatcher::OnSuccessIndexedDBKey(int32 ipc_thread_id,
                                                 int32 ipc_callbacks_id,
                                                 const IndexedDBKey& key) {
   DCHECK_EQ(ipc_thread_id, CurrentWorkerId());
   WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(ipc_callbacks_id);
   if (!callbacks)
     return;
-  callbacks->onSuccess(WebIDBKey(key));
+  callbacks->onSuccess(WebIDBKeyBuilder::Build(key));
   pending_callbacks_.Remove(ipc_callbacks_id);
 }
 
 void IndexedDBDispatcher::OnSuccessStringList(
     int32 ipc_thread_id,
     int32 ipc_callbacks_id,
     const std::vector<string16>& value) {
   DCHECK_EQ(ipc_thread_id, CurrentWorkerId());
   WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(ipc_callbacks_id);
   if (!callbacks)
@@ skipping 22 matching lines @@
     const std::string& value,
     const IndexedDBKey& primary_key,
     const IndexedDBKeyPath& key_path) {
   DCHECK_EQ(ipc_thread_id, CurrentWorkerId());
   WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(ipc_callbacks_id);
   if (!callbacks)
     return;
   WebData web_value;
   if (value.size())
     web_value.assign(&*value.begin(), value.size());
-  callbacks->onSuccess(web_value, primary_key, key_path);
+  callbacks->onSuccess(web_value,
+                       WebIDBKeyBuilder::Build(primary_key),
+                       WebIDBKeyPathBuilder::Build(key_path));
   pending_callbacks_.Remove(ipc_callbacks_id);
 }
 
 void IndexedDBDispatcher::OnSuccessInteger(int32 ipc_thread_id,
                                            int32 ipc_callbacks_id,
                                            int64 value) {
   DCHECK_EQ(ipc_thread_id, CurrentWorkerId());
   WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(ipc_callbacks_id);
   if (!callbacks)
     return;
@@ skipping 22 matching lines @@
   if (p.value.size())
     web_value.assign(&*p.value.begin(), p.value.size());
 
   WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(ipc_callbacks_id);
   if (!callbacks)
     return;
 
   RendererWebIDBCursorImpl* cursor =
       new RendererWebIDBCursorImpl(ipc_object_id, thread_safe_sender_.get());
   cursors_[ipc_object_id] = cursor;
-  callbacks->onSuccess(cursor, key, primary_key, web_value);
+  callbacks->onSuccess(cursor, WebIDBKeyBuilder::Build(key),
+                       WebIDBKeyBuilder::Build(primary_key), web_value);
 
   pending_callbacks_.Remove(ipc_callbacks_id);
 }
 
 void IndexedDBDispatcher::OnSuccessCursorContinue(
     const IndexedDBMsg_CallbacksSuccessCursorContinue_Params& p) {
   DCHECK_EQ(p.ipc_thread_id, CurrentWorkerId());
   int32 ipc_callbacks_id = p.ipc_callbacks_id;
   int32 ipc_cursor_id = p.ipc_cursor_id;
   const IndexedDBKey& key = p.key;
   const IndexedDBKey& primary_key = p.primary_key;
   const std::string& value = p.value;
 
   RendererWebIDBCursorImpl* cursor = cursors_[ipc_cursor_id];
   DCHECK(cursor);
 
   WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(ipc_callbacks_id);
   if (!callbacks)
     return;
 
   WebData web_value;
   if (value.size())
     web_value.assign(&*value.begin(), value.size());
-  callbacks->onSuccess(key, primary_key, web_value);
+  callbacks->onSuccess(WebIDBKeyBuilder::Build(key),
+                       WebIDBKeyBuilder::Build(primary_key), web_value);
 
   pending_callbacks_.Remove(ipc_callbacks_id);
 }
 
 void IndexedDBDispatcher::OnSuccessCursorPrefetch(
     const IndexedDBMsg_CallbacksSuccessCursorPrefetch_Params& p) {
   DCHECK_EQ(p.ipc_thread_id, CurrentWorkerId());
   int32 ipc_callbacks_id = p.ipc_callbacks_id;
   int32 ipc_cursor_id = p.ipc_cursor_id;
   const std::vector<IndexedDBKey>& keys = p.keys;
@@ skipping 110 matching lines @@
     int32 ipc_exception_cursor_id) {
   typedef std::map<int32, RendererWebIDBCursorImpl*>::iterator Iterator;
   for (Iterator i = cursors_.begin(); i != cursors_.end(); ++i) {
     if (i->first == ipc_exception_cursor_id)
       continue;
     i->second->ResetPrefetchCache();
   }
 }
 
 }  // namespace content