Revert "Migrate the IndexedDB backend from Blink to Chromium"

content/browser/indexed_db/indexed_db_callbacks_wrapper.cc

-// Copyright (c) 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/browser/indexed_db/indexed_db_callbacks_wrapper.h"
-
-#include "content/browser/indexed_db/indexed_db_cursor.h"
-#include "content/browser/indexed_db/indexed_db_metadata.h"
-#include "content/browser/indexed_db/webidbcursor_impl.h"
-#include "content/browser/indexed_db/webidbdatabase_impl.h"
-#include "third_party/WebKit/Source/Platform/chromium/public/WebData.h"
-#include "third_party/WebKit/Source/Platform/chromium/public/WebIDBDatabaseError.h"
-#include "third_party/WebKit/Source/Platform/chromium/public/WebIDBKey.h"
-#include "third_party/WebKit/Source/Platform/chromium/public/WebIDBMetadata.h"
-#include "third_party/WebKit/Source/Platform/chromium/public/WebString.h"
-#include "third_party/WebKit/Source/Platform/chromium/public/WebVector.h"
-
-namespace content {
-
-using WebKit::WebData;
-using WebKit::WebIDBKey;
-using WebKit::WebIDBMetadata;
-using WebKit::WebString;
-using WebKit::WebVector;
-
-IndexedDBCallbacksWrapper::IndexedDBCallbacksWrapper(
-    WebKit::WebIDBCallbacks* callbacks)
-    : callbacks_(callbacks), did_complete_(false), did_create_proxy_(false) {}
-
-IndexedDBCallbacksWrapper::~IndexedDBCallbacksWrapper() {}
-
-void IndexedDBCallbacksWrapper::OnError(
-    scoped_refptr<IndexedDBDatabaseError> error) {
-  DCHECK(callbacks_);
-  callbacks_->onError(
-      WebKit::WebIDBDatabaseError(error->code(), error->message()));
-  callbacks_.reset();
-}
-
-void IndexedDBCallbacksWrapper::OnSuccess(const std::vector<string16>& value) {
-  DCHECK(callbacks_);
-  callbacks_->onSuccess(WebVector<WebString>(value));
-  callbacks_.reset();
-}
-
-void IndexedDBCallbacksWrapper::OnSuccess(scoped_refptr<IndexedDBCursor> cursor,
-                                          const IndexedDBKey& key,
-                                          const IndexedDBKey& primary_key,
-                                          std::vector<char>* value) {
-  DCHECK(callbacks_);
-  WebData web_value;
-  if (value && value->size())
-    web_value.assign(&value->front(), value->size());
-  callbacks_->onSuccess(
-      new WebIDBCursorImpl(cursor), WebIDBKey(key), primary_key, web_value);
-  callbacks_.reset();
-}
-
-void IndexedDBCallbacksWrapper::OnSuccess(const IndexedDBKey& key) {
-  DCHECK(callbacks_);
-  callbacks_->onSuccess(WebIDBKey(key));
-  callbacks_.reset();
-}
-
-void IndexedDBCallbacksWrapper::OnSuccess(std::vector<char>* value) {
-  WebData web_value;
-  if (value && value->size())
-    web_value.assign(&value->front(), value->size());
-
-  DCHECK(callbacks_);
-  callbacks_->onSuccess(web_value);
-  callbacks_.reset();
-}
-
-void IndexedDBCallbacksWrapper::OnSuccess(std::vector<char>* value,
-                                          const IndexedDBKey& key,
-                                          const IndexedDBKeyPath& key_path) {
-  WebData web_value;
-  if (value && value->size())
-    web_value.assign(&value->front(), value->size());
-  DCHECK(callbacks_);
-  callbacks_->onSuccess(web_value, WebIDBKey(key), key_path);
-  callbacks_.reset();
-}
-
-void IndexedDBCallbacksWrapper::OnSuccess(int64 value) {
-  DCHECK(callbacks_);
-  callbacks_->onSuccess(value);
-  callbacks_.reset();
-}
-
-void IndexedDBCallbacksWrapper::OnSuccess() {
-  DCHECK(callbacks_);
-  callbacks_->onSuccess();
-  callbacks_.reset();
-}
-
-void IndexedDBCallbacksWrapper::OnSuccess(const IndexedDBKey& key,
-                                          const IndexedDBKey& primary_key,
-                                          std::vector<char>* value) {
-  WebData web_value;
-  if (value && value->size())
-    web_value.assign(&value->front(), value->size());
-  DCHECK(callbacks_);
-  callbacks_->onSuccess(key, primary_key, web_value);
-  callbacks_.reset();
-}
-
-void IndexedDBCallbacksWrapper::OnSuccessWithPrefetch(
-    const std::vector<IndexedDBKey>& keys,
-    const std::vector<IndexedDBKey>& primary_keys,
-    const std::vector<std::vector<char> >& values) {
-  DCHECK_EQ(keys.size(), primary_keys.size());
-  DCHECK_EQ(keys.size(), values.size());
-
-  std::vector<WebIDBKey> web_keys(keys.size());
-  std::vector<WebIDBKey> web_primary_keys(primary_keys.size());
-  std::vector<WebData> web_values(values.size());
-  for (size_t i = 0; i < keys.size(); ++i) {
-    web_keys[i] = keys[i];
-    web_primary_keys[i] = primary_keys[i];
-    if (values[i].size())
-      web_values[i].assign(&values[i].front(), values[i].size());
-  }
-
-  DCHECK(callbacks_);
-  callbacks_->onSuccessWithPrefetch(web_keys, web_primary_keys, web_values);
-  callbacks_.reset();
-}
-
-void IndexedDBCallbacksWrapper::OnBlocked(int64 existing_version) {
-  DCHECK(callbacks_);
-  callbacks_->onBlocked(existing_version);
-}
-
-WebIDBMetadata ConvertMetadata(const IndexedDBDatabaseMetadata& idb_metadata) {
-  WebIDBMetadata web_metadata;
-  web_metadata.id = idb_metadata.id;
-  web_metadata.name = idb_metadata.name;
-  web_metadata.version = idb_metadata.version;
-  web_metadata.intVersion = idb_metadata.int_version;
-  web_metadata.maxObjectStoreId = idb_metadata.max_object_store_id;
-  web_metadata.objectStores =
-      WebVector<WebIDBMetadata::ObjectStore>(idb_metadata.object_stores.size());
-
-  size_t i = 0;
-  for (IndexedDBDatabaseMetadata::ObjectStoreMap::const_iterator
-           it = idb_metadata.object_stores.begin();
-       it != idb_metadata.object_stores.end();
-       ++it, ++i) {
-    const IndexedDBObjectStoreMetadata& idb_store_metadata = it->second;
-    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.key_path;
-    web_store_metadata.autoIncrement = idb_store_metadata.auto_increment;
-    web_store_metadata.maxIndexId = idb_store_metadata.max_index_id;
-    web_store_metadata.indexes =
-        WebVector<WebIDBMetadata::Index>(idb_store_metadata.indexes.size());
-
-    size_t j = 0;
-    for (IndexedDBObjectStoreMetadata::IndexMap::const_iterator
-             it2 = idb_store_metadata.indexes.begin();
-         it2 != idb_store_metadata.indexes.end();
-         ++it2, ++j) {
-      const IndexedDBIndexMetadata& idb_index_metadata = it2->second;
-      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.key_path;
-      web_index_metadata.unique = idb_index_metadata.unique;
-      web_index_metadata.multiEntry = idb_index_metadata.multi_entry;
-    }
-  }
-
-  return web_metadata;
-}
-
-void IndexedDBCallbacksWrapper::OnUpgradeNeeded(
-    int64 old_version,
-    scoped_refptr<IndexedDBDatabase> database,
-    const IndexedDBDatabaseMetadata& metadata) {
-  DCHECK(callbacks_);
-  WebIDBMetadata web_metadata = ConvertMetadata(metadata);
-  did_create_proxy_ = true;
-  callbacks_->onUpgradeNeeded(
-      old_version,
-      new WebIDBDatabaseImpl(database, database_callbacks_),
-      web_metadata);
-  database_callbacks_ = NULL;
-}
-
-void IndexedDBCallbacksWrapper::OnSuccess(
-    scoped_refptr<IndexedDBDatabase> database,
-    const IndexedDBDatabaseMetadata& metadata) {
-  DCHECK(callbacks_);
-  WebIDBMetadata web_metadata = ConvertMetadata(metadata);
-  scoped_refptr<IndexedDBCallbacksWrapper> self(this);
-
-  WebIDBDatabaseImpl* impl =
-      did_create_proxy_ ? 0
-                        : new WebIDBDatabaseImpl(database, database_callbacks_);
-  database_callbacks_ = NULL;
-
-  callbacks_->onSuccess(impl, web_metadata);
-  callbacks_.reset();
-}
-
-void IndexedDBCallbacksWrapper::SetDatabaseCallbacks(
-    scoped_refptr<IndexedDBDatabaseCallbacksWrapper> database_callbacks) {
-  database_callbacks_ = database_callbacks;
-}
-}  // namespace content