IndexedDB: Remove uses of WebKit API types from back-end code

content/browser/indexed_db/indexed_db_dispatcher_host.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/browser/indexed_db/indexed_db_dispatcher_host.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/process.h"
 #include "base/process_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/indexed_db/indexed_db_callbacks.h"
 #include "content/browser/indexed_db/indexed_db_context_impl.h"
 #include "content/browser/indexed_db/indexed_db_database_callbacks.h"
 #include "content/browser/indexed_db/indexed_db_metadata.h"
 #include "content/browser/indexed_db/webidbcursor_impl.h"
 #include "content/browser/indexed_db/webidbcursor_impl.h"
 #include "content/browser/indexed_db/webidbdatabase_impl.h"
 #include "content/browser/renderer_host/render_message_filter.h"
 #include "content/common/indexed_db/indexed_db_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/result_codes.h"
 #include "googleurl/src/gurl.h"
 #include "third_party/WebKit/public/platform/WebIDBDatabase.h"
-#include "third_party/WebKit/public/platform/WebIDBDatabaseError.h"
 #include "third_party/WebKit/public/platform/WebIDBDatabaseException.h"
 #include "webkit/browser/database/database_util.h"
 #include "webkit/common/database/database_identifier.h"
 
 using webkit_database::DatabaseUtil;
-using WebKit::WebIDBDatabaseError;
 using WebKit::WebIDBKey;
 
 namespace content {
 
+static const char* kQuotaExceededErrorMessage =
+    "An attempt was made to add something to storage that exceeded the quota.";

[jamesr, 2013/06/26 20:08:25]

shouldn't this go in a resources file somewhere?

[jsbell, 2013/06/26 20:14:28]

Exception messages aren't localized. This particular string is copied from
DOMException.cpp in Blink. Alternately, we could pass an empty string through
and use that as a trigger to look up the message on the Blink side.

[jsbell, 2013/06/26 22:12:47]

Changed it to pass through blank messages if the front-end should fill in, and
call the 1 or 2 param version of WebIDBDatabaseError::create() as appropriate.

+
 IndexedDBDispatcherHost::IndexedDBDispatcherHost(
     int ipc_process_id,
     IndexedDBContextImpl* indexed_db_context)
     : indexed_db_context_(indexed_db_context),
       database_dispatcher_host_(new DatabaseDispatcherHost(this)),
       cursor_dispatcher_host_(new CursorDispatcherHost(this)),
       ipc_process_id_(ipc_process_id) {
   DCHECK(indexed_db_context_.get());
 }
 
@@ skipping 163 matching lines @@
 }
 
 void IndexedDBDispatcherHost::OnIDBFactoryGetDatabaseNames(
     const IndexedDBHostMsg_FactoryGetDatabaseNames_Params& params) {
   DCHECK(indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   base::FilePath indexed_db_path = indexed_db_context_->data_path();
 
   Context()->GetIDBFactory()->getDatabaseNames(
       new IndexedDBCallbacks<std::vector<string16> >(
           this, params.ipc_thread_id, params.ipc_callbacks_id),
-      WebKit::WebString::fromUTF8(params.database_identifier),
+      base::UTF8ToUTF16(params.database_identifier),
       indexed_db_path.AsUTF16Unsafe());
 }
 
 void IndexedDBDispatcherHost::OnIDBFactoryOpen(
     const IndexedDBHostMsg_FactoryOpen_Params& params) {
   DCHECK(indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   base::FilePath indexed_db_path = indexed_db_context_->data_path();
 
   GURL origin_url =
       webkit_database::GetOriginFromIdentifier(params.database_identifier);
 
   int64 host_transaction_id = HostTransactionId(params.transaction_id);
 
   // TODO(dgrogan): Don't let a non-existing database be opened (and therefore
   // created) if this origin is already over quota.
   Context()->GetIDBFactory()
       ->open(params.name,
              params.version,
              host_transaction_id,
              new IndexedDBCallbacksDatabase(this,
                                             params.ipc_thread_id,
                                             params.ipc_callbacks_id,
                                             params.ipc_database_callbacks_id,
                                             host_transaction_id,
                                             origin_url),
              new IndexedDBDatabaseCallbacks(
                  this, params.ipc_thread_id, params.ipc_database_callbacks_id),
-             WebKit::WebString::fromUTF8(params.database_identifier),
+             base::UTF8ToUTF16(params.database_identifier),
              indexed_db_path.AsUTF16Unsafe());
 }
 
 void IndexedDBDispatcherHost::OnIDBFactoryDeleteDatabase(
     const IndexedDBHostMsg_FactoryDeleteDatabase_Params& params) {
   DCHECK(indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   base::FilePath indexed_db_path = indexed_db_context_->data_path();
 
   Context()->GetIDBFactory()
       ->deleteDatabase(params.name,
                        new IndexedDBCallbacks<std::vector<char> >(
                            this, params.ipc_thread_id, params.ipc_callbacks_id),
-                       WebKit::WebString::fromUTF8(params.database_identifier),
+                       base::UTF8ToUTF16(params.database_identifier),
                        indexed_db_path.AsUTF16Unsafe());
 }
 
 void IndexedDBDispatcherHost::FinishTransaction(int64 host_transaction_id,
                                                 bool committed) {
   DCHECK(indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   TransactionIDToURLMap& transaction_url_map =
       database_dispatcher_host_->transaction_url_map_;
   TransactionIDToSizeMap& transaction_size_map =
       database_dispatcher_host_->transaction_size_map_;
@@ skipping 67 matching lines @@
   for (TransactionIDToDatabaseIDMap::iterator iter =
            transaction_database_map_.begin();
        iter != transaction_database_map_.end();) {
     int64 transaction_id = iter->first;
     int32 ipc_database_id = iter->second;
     ++iter;
     WebIDBDatabaseImpl* database = map_.Lookup(ipc_database_id);
     if (database) {
       database->abort(
           transaction_id,
-          WebIDBDatabaseError(WebKit::WebIDBDatabaseExceptionUnknownError));
+          IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionUnknownError,
+                                 "Connection closed."));
     }
   }
   DCHECK(transaction_database_map_.empty());
 
   for (WebIDBObjectIDToURLMap::iterator iter = database_url_map_.begin();
        iter != database_url_map_.end();
        iter++) {
     WebIDBDatabaseImpl* database = map_.Lookup(iter->first);
     if (database) {
       database->close();
@@ skipping 53 matching lines @@
   int64 host_transaction_id = parent_->HostTransactionId(params.transaction_id);
   database->createObjectStore(host_transaction_id,
                               params.object_store_id,
                               params.name,
                               params.key_path,
                               params.auto_increment);
   if (parent_->Context()->IsOverQuota(
           database_url_map_[params.ipc_database_id])) {
     database->abort(
         host_transaction_id,
-        WebIDBDatabaseError(WebKit::WebIDBDatabaseExceptionQuotaError));
+        IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionQuotaError,
+                               kQuotaExceededErrorMessage));
   }
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnDeleteObjectStore(
     int32 ipc_database_id,
     int64 transaction_id,
     int64 object_store_id) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   WebIDBDatabaseImpl* database =
@@ skipping 106 matching lines @@
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   WebIDBDatabaseImpl* database =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!database)
     return;
 
   int64 host_transaction_id = parent_->HostTransactionId(params.transaction_id);
   if (params.index_ids.size() != params.index_keys.size()) {
     database->abort(
         host_transaction_id,
-        WebIDBDatabaseError(
+        IndexedDBDatabaseError(
             WebKit::WebIDBDatabaseExceptionUnknownError,
             "Malformed IPC message: index_ids.size() != index_keys.size()"));
     return;
   }
 
   database->setIndexKeys(host_transaction_id,
                          params.object_store_id,
                          params.primary_key,
                          params.index_ids,
                          params.index_keys);
@@ skipping 119 matching lines @@
   if (!database)
     return;
 
   int64 host_transaction_id = parent_->HostTransactionId(transaction_id);
   int64 transaction_size = transaction_size_map_[host_transaction_id];
   if (transaction_size &&
       parent_->Context()->WouldBeOverQuota(
           transaction_url_map_[host_transaction_id], transaction_size)) {
     database->abort(
         host_transaction_id,
-        WebIDBDatabaseError(WebKit::WebIDBDatabaseExceptionQuotaError));
+        IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionQuotaError,
+                               kQuotaExceededErrorMessage));
     return;
   }
 
   database->commit(host_transaction_id);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnCreateIndex(
     const IndexedDBHostMsg_DatabaseCreateIndex_Params& params) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   WebIDBDatabaseImpl* database =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!database)
     return;
 
   int64 host_transaction_id = parent_->HostTransactionId(params.transaction_id);
   database->createIndex(host_transaction_id,
                         params.object_store_id,
                         params.index_id,
                         params.name,
                         params.key_path,
                         params.unique,
                         params.multi_entry);
   if (parent_->Context()->IsOverQuota(
           database_url_map_[params.ipc_database_id])) {
     database->abort(
         host_transaction_id,
-        WebIDBDatabaseError(WebKit::WebIDBDatabaseExceptionQuotaError));
+        IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionQuotaError,
+                               kQuotaExceededErrorMessage));
   }
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnDeleteIndex(
     int32 ipc_database_id,
     int64 transaction_id,
     int64 object_store_id,
     int64 index_id) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
@@ skipping 111 matching lines @@
 }
 
 void IndexedDBDispatcherHost::CursorDispatcherHost::OnDestroyed(
     int32 ipc_object_id) {
   DCHECK(
       parent_->indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
   parent_->DestroyObject(&map_, ipc_object_id);
 }
 
 }  // namespace content