Rename WebKit namespace to blink (part 3)

content/browser/indexed_db/indexed_db_database.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_database.h"
 
 #include <math.h>
 #include <set>
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/indexed_db/indexed_db_connection.h"
 #include "content/browser/indexed_db/indexed_db_cursor.h"
 #include "content/browser/indexed_db/indexed_db_factory.h"
 #include "content/browser/indexed_db/indexed_db_index_writer.h"
 #include "content/browser/indexed_db/indexed_db_tracing.h"
 #include "content/browser/indexed_db/indexed_db_transaction.h"
 #include "content/common/indexed_db/indexed_db_key_path.h"
 #include "content/common/indexed_db/indexed_db_key_range.h"
 #include "content/public/browser/browser_thread.h"
 #include "third_party/WebKit/public/platform/WebIDBDatabaseException.h"
 
 using base::Int64ToString16;
-using WebKit::WebIDBKeyTypeNumber;
+using blink::WebIDBKeyTypeNumber;
 
 namespace content {
 
 // PendingOpenCall has a scoped_refptr<IndexedDBDatabaseCallbacks> because it
 // isn't a connection yet.
 class IndexedDBDatabase::PendingOpenCall {
  public:
   PendingOpenCall(scoped_refptr<IndexedDBCallbacks> callbacks,
                   scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
                   int64 transaction_id,
@@ skipping 278 matching lines @@
     IndexedDBTransaction* transaction) {
   IDB_TRACE("IndexedDBDatabase::CreateObjectStoreOperation");
   if (!backing_store_->CreateObjectStore(
           transaction->BackingStoreTransaction(),
           transaction->database()->id(),
           object_store_metadata.id,
           object_store_metadata.name,
           object_store_metadata.key_path,
           object_store_metadata.auto_increment)) {
     transaction->Abort(IndexedDBDatabaseError(
-        WebKit::WebIDBDatabaseExceptionUnknownError,
+        blink::WebIDBDatabaseExceptionUnknownError,
         ASCIIToUTF16("Internal error creating object store '") +
             object_store_metadata.name + ASCIIToUTF16("'.")));
     return;
   }
 }
 
 void IndexedDBDatabase::DeleteObjectStore(int64 transaction_id,
                                           int64 object_store_id) {
   IDB_TRACE("IndexedDBDatabase::DeleteObjectStore");
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
@@ skipping 57 matching lines @@
                                    transaction->database()->id(),
                                    object_store_id,
                                    index_metadata.id,
                                    index_metadata.name,
                                    index_metadata.key_path,
                                    index_metadata.unique,
                                    index_metadata.multi_entry)) {
     string16 error_string = ASCIIToUTF16("Internal error creating index '") +
                             index_metadata.name + ASCIIToUTF16("'.");
     transaction->Abort(IndexedDBDatabaseError(
-        WebKit::WebIDBDatabaseExceptionUnknownError, error_string));
+        blink::WebIDBDatabaseExceptionUnknownError, error_string));
     return;
   }
 }
 
 void IndexedDBDatabase::CreateIndexAbortOperation(
     int64 object_store_id,
     int64 index_id,
     IndexedDBTransaction* transaction) {
   IDB_TRACE("IndexedDBDatabase::CreateIndexAbortOperation");
   DCHECK(!transaction);
@@ skipping 33 matching lines @@
     IndexedDBTransaction* transaction) {
   IDB_TRACE("IndexedDBDatabase::DeleteIndexOperation");
   bool ok = backing_store_->DeleteIndex(transaction->BackingStoreTransaction(),
                                         transaction->database()->id(),
                                         object_store_id,
                                         index_metadata.id);
   if (!ok) {
     string16 error_string = ASCIIToUTF16("Internal error deleting index '") +
                             index_metadata.name + ASCIIToUTF16("'.");
     transaction->Abort(IndexedDBDatabaseError(
-        WebKit::WebIDBDatabaseExceptionUnknownError, error_string));
+        blink::WebIDBDatabaseExceptionUnknownError, error_string));
   }
 }
 
 void IndexedDBDatabase::DeleteIndexAbortOperation(
     int64 object_store_id,
     const IndexedDBIndexMetadata& index_metadata,
     IndexedDBTransaction* transaction) {
   IDB_TRACE("IndexedDBDatabase::DeleteIndexAbortOperation");
   DCHECK(!transaction);
   AddIndex(object_store_id, index_metadata, IndexedDBIndexMetadata::kInvalidId);
@@ skipping 112 matching lines @@
   if (index_id == IndexedDBIndexMetadata::kInvalidId) {
     // Object Store Retrieval Operation
     std::string value;
     ok = backing_store_->GetRecord(transaction->BackingStoreTransaction(),
                                    id(),
                                    object_store_id,
                                    *key,
                                    &value);
     if (!ok) {
       callbacks->OnError(
-          IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionUnknownError,
+          IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Internal error in GetRecord."));
       return;
     }
 
     if (value.empty()) {
       callbacks->OnSuccess();
       return;
     }
 
     if (object_store_metadata.auto_increment &&
         !object_store_metadata.key_path.IsNull()) {
       callbacks->OnSuccess(&value, *key, object_store_metadata.key_path);
       return;
     }
 
     callbacks->OnSuccess(&value);
     return;
   }
 
   // From here we are dealing only with indexes.
   ok = backing_store_->GetPrimaryKeyViaIndex(
       transaction->BackingStoreTransaction(),
       id(),
       object_store_id,
       index_id,
       *key,
       &primary_key);
   if (!ok) {
     callbacks->OnError(
-        IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionUnknownError,
+        IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError,
                                "Internal error in GetPrimaryKeyViaIndex."));
     return;
   }
   if (!primary_key) {
     callbacks->OnSuccess();
     return;
   }
   if (cursor_type == indexed_db::CURSOR_KEY_ONLY) {
     // Index Value Retrieval Operation
     callbacks->OnSuccess(*primary_key);
     return;
   }
 
   // Index Referenced Value Retrieval Operation
   std::string value;
   ok = backing_store_->GetRecord(transaction->BackingStoreTransaction(),
                                  id(),
                                  object_store_id,
                                  *primary_key,
                                  &value);
   if (!ok) {
     callbacks->OnError(
-        IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionUnknownError,
+        IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError,
                                "Internal error in GetRecord."));
     return;
   }
 
   if (value.empty()) {
     callbacks->OnSuccess();
     return;
   }
   if (object_store_metadata.auto_increment &&
       !object_store_metadata.key_path.IsNull()) {
@@ skipping 99 matching lines @@
   DCHECK(object_store.auto_increment || params->key->IsValid());
 
   scoped_ptr<IndexedDBKey> key;
   if (params->put_mode != IndexedDBDatabase::CURSOR_UPDATE &&
       object_store.auto_increment && !params->key->IsValid()) {
     scoped_ptr<IndexedDBKey> auto_inc_key =
         GenerateKey(backing_store_, transaction, id(), params->object_store_id);
     key_was_generated = true;
     if (!auto_inc_key->IsValid()) {
       params->callbacks->OnError(
-          IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionConstraintError,
+          IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionConstraintError,
                                  "Maximum key generator value reached."));
       return;
     }
     key = auto_inc_key.Pass();
   } else {
     key = params->key.Pass();
   }
 
   DCHECK(key->IsValid());
 
   IndexedDBBackingStore::RecordIdentifier record_identifier;
   if (params->put_mode == IndexedDBDatabase::ADD_ONLY) {
     bool found = false;
     bool ok = backing_store_->KeyExistsInObjectStore(
         transaction->BackingStoreTransaction(),
         id(),
         params->object_store_id,
         *key,
         &record_identifier,
         &found);
     if (!ok) {
       params->callbacks->OnError(
-          IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionUnknownError,
+          IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Internal error checking key existence."));
       return;
     }
     if (found) {
       params->callbacks->OnError(
-          IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionConstraintError,
+          IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionConstraintError,
                                  "Key already exists in the object store."));
       return;
     }
   }
 
   ScopedVector<IndexWriter> index_writers;
   string16 error_message;
   bool obeys_constraints = false;
   bool backing_store_success = MakeIndexWriters(transaction,
                                                 backing_store_.get(),
                                                 id(),
                                                 object_store,
                                                 *key,
                                                 key_was_generated,
                                                 params->index_ids,
                                                 params->index_keys,
                                                 &index_writers,
                                                 &error_message,
                                                 &obeys_constraints);
   if (!backing_store_success) {
     params->callbacks->OnError(IndexedDBDatabaseError(
-        WebKit::WebIDBDatabaseExceptionUnknownError,
+        blink::WebIDBDatabaseExceptionUnknownError,
         "Internal error: backing store error updating index keys."));
     return;
   }
   if (!obeys_constraints) {
     params->callbacks->OnError(IndexedDBDatabaseError(
-        WebKit::WebIDBDatabaseExceptionConstraintError, error_message));
+        blink::WebIDBDatabaseExceptionConstraintError, error_message));
     return;
   }
 
   // Before this point, don't do any mutation. After this point, rollback the
   // transaction in case of error.
   backing_store_success =
       backing_store_->PutRecord(transaction->BackingStoreTransaction(),
                                 id(),
                                 params->object_store_id,
                                 *key,
                                 params->value,
                                 &record_identifier);
   if (!backing_store_success) {
     params->callbacks->OnError(IndexedDBDatabaseError(
-        WebKit::WebIDBDatabaseExceptionUnknownError,
+        blink::WebIDBDatabaseExceptionUnknownError,
         "Internal error: backing store error performing put/add."));
     return;
   }
 
   for (size_t i = 0; i < index_writers.size(); ++i) {
     IndexWriter* index_writer = index_writers[i];
     index_writer->WriteIndexKeys(record_identifier,
                                  backing_store_.get(),
                                  transaction->BackingStoreTransaction(),
                                  id(),
                                  params->object_store_id);
   }
 
   if (object_store.auto_increment &&
       params->put_mode != IndexedDBDatabase::CURSOR_UPDATE &&
       key->type() == WebIDBKeyTypeNumber) {
     bool ok = UpdateKeyGenerator(backing_store_,
                                  transaction,
                                  id(),
                                  params->object_store_id,
                                  *key,
                                  !key_was_generated);
     if (!ok) {
       params->callbacks->OnError(
-          IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionUnknownError,
+          IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Internal error updating key generator."));
       return;
     }
   }
 
   params->callbacks->OnSuccess(*key);
 }
 
 void IndexedDBDatabase::SetIndexKeys(int64 transaction_id,
                                      int64 object_store_id,
@@ skipping 12 matching lines @@
   bool found = false;
   bool ok = backing_store_->KeyExistsInObjectStore(
       transaction->BackingStoreTransaction(),
       metadata_.id,
       object_store_id,
       *primary_key,
       &record_identifier,
       &found);
   if (!ok) {
     transaction->Abort(
-        IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionUnknownError,
+        IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError,
                                "Internal error setting index keys."));
     return;
   }
   if (!found) {
     transaction->Abort(IndexedDBDatabaseError(
-        WebKit::WebIDBDatabaseExceptionUnknownError,
+        blink::WebIDBDatabaseExceptionUnknownError,
         "Internal error setting index keys for object store."));
     return;
   }
 
   ScopedVector<IndexWriter> index_writers;
   string16 error_message;
   bool obeys_constraints = false;
   DCHECK(metadata_.object_stores.find(object_store_id) !=
          metadata_.object_stores.end());
   const IndexedDBObjectStoreMetadata& object_store_metadata =
       metadata_.object_stores[object_store_id];
   bool backing_store_success = MakeIndexWriters(transaction,
                                                 backing_store_,
                                                 id(),
                                                 object_store_metadata,
                                                 *primary_key,
                                                 false,
                                                 index_ids,
                                                 index_keys,
                                                 &index_writers,
                                                 &error_message,
                                                 &obeys_constraints);
   if (!backing_store_success) {
     transaction->Abort(IndexedDBDatabaseError(
-        WebKit::WebIDBDatabaseExceptionUnknownError,
+        blink::WebIDBDatabaseExceptionUnknownError,
         "Internal error: backing store error updating index keys."));
     return;
   }
   if (!obeys_constraints) {
     transaction->Abort(IndexedDBDatabaseError(
-        WebKit::WebIDBDatabaseExceptionConstraintError, error_message));
+        blink::WebIDBDatabaseExceptionConstraintError, error_message));
     return;
   }
 
   for (size_t i = 0; i < index_writers.size(); ++i) {
     IndexWriter* index_writer = index_writers[i];
     index_writer->WriteIndexKeys(record_identifier,
                                  backing_store_,
                                  transaction->BackingStoreTransaction(),
                                  id(),
                                  object_store_id);
@@ skipping 226 matching lines @@
           *key_range,
           indexed_db::CURSOR_NEXT);
   if (backing_store_cursor) {
     do {
       if (!backing_store_->DeleteRecord(
               transaction->BackingStoreTransaction(),
               id(),
               object_store_id,
               backing_store_cursor->record_identifier())) {
         callbacks->OnError(
-            IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionUnknownError,
+            IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError,
                                    "Internal error deleting data in range"));
         return;
       }
     } while (backing_store_cursor->Continue());
   }
 
   callbacks->OnSuccess();
 }
 
 void IndexedDBDatabase::Clear(int64 transaction_id,
@@ skipping 13 matching lines @@
 }
 
 void IndexedDBDatabase::ClearOperation(
     int64 object_store_id,
     scoped_refptr<IndexedDBCallbacks> callbacks,
     IndexedDBTransaction* transaction) {
   IDB_TRACE("IndexedDBDatabase::ObjectStoreClearOperation");
   if (!backing_store_->ClearObjectStore(
           transaction->BackingStoreTransaction(), id(), object_store_id)) {
     callbacks->OnError(
-        IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionUnknownError,
+        IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError,
                                "Internal error clearing object store"));
     return;
   }
   callbacks->OnSuccess();
 }
 
 void IndexedDBDatabase::DeleteObjectStoreOperation(
     const IndexedDBObjectStoreMetadata& object_store_metadata,
     IndexedDBTransaction* transaction) {
   IDB_TRACE("IndexedDBDatabase::DeleteObjectStoreOperation");
   bool ok =
       backing_store_->DeleteObjectStore(transaction->BackingStoreTransaction(),
                                         transaction->database()->id(),
                                         object_store_metadata.id);
   if (!ok) {
     string16 error_string =
         ASCIIToUTF16("Internal error deleting object store '") +
         object_store_metadata.name + ASCIIToUTF16("'.");
     transaction->Abort(IndexedDBDatabaseError(
-        WebKit::WebIDBDatabaseExceptionUnknownError, error_string));
+        blink::WebIDBDatabaseExceptionUnknownError, error_string));
   }
 }
 
 void IndexedDBDatabase::VersionChangeOperation(
     int64 version,
     scoped_refptr<IndexedDBCallbacks> callbacks,
     scoped_ptr<IndexedDBConnection> connection,
-    WebKit::WebIDBCallbacks::DataLoss data_loss,
+    blink::WebIDBCallbacks::DataLoss data_loss,
     std::string data_loss_message,
     IndexedDBTransaction* transaction) {
   IDB_TRACE("IndexedDBDatabase::VersionChangeOperation");
   int64 old_version = metadata_.int_version;
   DCHECK_GT(version, old_version);
   metadata_.int_version = version;
   if (!backing_store_->UpdateIDBDatabaseIntVersion(
           transaction->BackingStoreTransaction(),
           id(),
           metadata_.int_version)) {
     IndexedDBDatabaseError error(
-        WebKit::WebIDBDatabaseExceptionUnknownError,
+        blink::WebIDBDatabaseExceptionUnknownError,
         ASCIIToUTF16(
             "Internal error writing data to stable storage when "
             "updating version."));
     callbacks->OnError(error);
     transaction->Abort(error);
     return;
   }
   DCHECK(!pending_second_half_open_);
   pending_second_half_open_.reset(new PendingSuccessCall(
       callbacks, connection.get(), transaction->id(), version));
@@ skipping 18 matching lines @@
     DCHECK_EQ(transaction, running_version_change_transaction_);
     running_version_change_transaction_ = NULL;
   }
 }
 
 void IndexedDBDatabase::TransactionFinishedAndAbortFired(
     IndexedDBTransaction* transaction) {
   if (transaction->mode() == indexed_db::TRANSACTION_VERSION_CHANGE) {
     if (pending_second_half_open_) {
       pending_second_half_open_->Callbacks()->OnError(
-          IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionAbortError,
+          IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionAbortError,
                                  "Version change transaction was aborted in "
                                  "upgradeneeded event handler."));
       pending_second_half_open_.reset();
     }
     ProcessPendingCalls();
   }
 }
 
 void IndexedDBDatabase::TransactionFinishedAndCompleteFired(
     IndexedDBTransaction* transaction) {
@@ skipping 112 matching lines @@
   return !pending_delete_calls_.empty() ||
          running_version_change_transaction_ ||
          pending_run_version_change_transaction_call_;
 }
 
 void IndexedDBDatabase::OpenConnection(
     scoped_refptr<IndexedDBCallbacks> callbacks,
     scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
     int64 transaction_id,
     int64 version) {
-  const WebKit::WebIDBCallbacks::DataLoss kDataLoss =
-      WebKit::WebIDBCallbacks::DataLossNone;
+  const blink::WebIDBCallbacks::DataLoss kDataLoss =
+      blink::WebIDBCallbacks::DataLossNone;
   OpenConnection(
       callbacks, database_callbacks, transaction_id, version, kDataLoss, "");
 }
 
 void IndexedDBDatabase::OpenConnection(
     scoped_refptr<IndexedDBCallbacks> callbacks,
     scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
     int64 transaction_id,
     int64 version,
-    WebKit::WebIDBCallbacks::DataLoss data_loss,
+    blink::WebIDBCallbacks::DataLoss data_loss,
     std::string data_loss_message) {
   DCHECK(backing_store_);
 
   // TODO(jsbell): Should have a priority queue so that higher version
   // requests are processed first. http://crbug.com/225850
   if (IsOpenConnectionBlocked()) {
     // The backing store only detects data loss when it is first opened. The
     // presence of existing connections means we didn't even check for data loss
     // so there'd better not be any.
-    DCHECK_NE(WebKit::WebIDBCallbacks::DataLossTotal, data_loss);
+    DCHECK_NE(blink::WebIDBCallbacks::DataLossTotal, data_loss);
     pending_open_calls_.push_back(new PendingOpenCall(
         callbacks, database_callbacks, transaction_id, version));
     return;
   }
 
   if (metadata_.id == kInvalidId) {
     // The database was deleted then immediately re-opened; OpenInternal()
     // recreates it in the backing store.
     if (OpenInternal()) {
       DCHECK_EQ(IndexedDBDatabaseMetadata::NO_INT_VERSION,
                 metadata_.int_version);
     } else {
       string16 message;
       if (version == IndexedDBDatabaseMetadata::NO_INT_VERSION)
         message = ASCIIToUTF16(
             "Internal error opening database with no version specified.");
       else
         message =
             ASCIIToUTF16("Internal error opening database with version ") +
             Int64ToString16(version);
       callbacks->OnError(IndexedDBDatabaseError(
-          WebKit::WebIDBDatabaseExceptionUnknownError, message));
+          blink::WebIDBDatabaseExceptionUnknownError, message));
       return;
     }
   }
 
   // We infer that the database didn't exist from its lack of either type of
   // version.
   bool is_new_database =
       metadata_.version == kNoStringVersion &&
       metadata_.int_version == IndexedDBDatabaseMetadata::NO_INT_VERSION;
 
@@ skipping 26 matching lines @@
     RunVersionChangeTransaction(callbacks,
                                 connection.Pass(),
                                 transaction_id,
                                 version,
                                 data_loss,
                                 data_loss_message);
     return;
   }
   if (version < metadata_.int_version) {
     callbacks->OnError(IndexedDBDatabaseError(
-        WebKit::WebIDBDatabaseExceptionVersionError,
+        blink::WebIDBDatabaseExceptionVersionError,
         ASCIIToUTF16("The requested version (") + Int64ToString16(version) +
             ASCIIToUTF16(") is less than the existing version (") +
             Int64ToString16(metadata_.int_version) + ASCIIToUTF16(").")));
     return;
   }
   DCHECK_EQ(version, metadata_.int_version);
   connections_.insert(connection.get());
   callbacks->OnSuccess(connection.Pass(), this->metadata());
 }
 
 void IndexedDBDatabase::RunVersionChangeTransaction(
     scoped_refptr<IndexedDBCallbacks> callbacks,
     scoped_ptr<IndexedDBConnection> connection,
     int64 transaction_id,
     int64 requested_version,
-    WebKit::WebIDBCallbacks::DataLoss data_loss,
+    blink::WebIDBCallbacks::DataLoss data_loss,
     std::string data_loss_message) {
 
   DCHECK(callbacks);
   DCHECK(connections_.count(connection.get()));
   if (ConnectionCount() > 1) {
-    DCHECK_NE(WebKit::WebIDBCallbacks::DataLossTotal, data_loss);
+    DCHECK_NE(blink::WebIDBCallbacks::DataLossTotal, data_loss);
     // Front end ensures the event is not fired at connections that have
     // close_pending set.
     for (ConnectionSet::const_iterator it = connections_.begin();
          it != connections_.end();
          ++it) {
       if (*it != connection.get()) {
         (*it)->callbacks()->OnVersionChange(metadata_.int_version,
                                             requested_version);
       }
     }
@@ skipping 13 matching lines @@
                                    requested_version,
                                    data_loss,
                                    data_loss_message);
 }
 
 void IndexedDBDatabase::RunVersionChangeTransactionFinal(
     scoped_refptr<IndexedDBCallbacks> callbacks,
     scoped_ptr<IndexedDBConnection> connection,
     int64 transaction_id,
     int64 requested_version) {
-  const WebKit::WebIDBCallbacks::DataLoss kDataLoss =
-      WebKit::WebIDBCallbacks::DataLossNone;
+  const blink::WebIDBCallbacks::DataLoss kDataLoss =
+      blink::WebIDBCallbacks::DataLossNone;
   RunVersionChangeTransactionFinal(callbacks,
                                    connection.Pass(),
                                    transaction_id,
                                    requested_version,
                                    kDataLoss,
                                    "");
 }
 
 void IndexedDBDatabase::RunVersionChangeTransactionFinal(
     scoped_refptr<IndexedDBCallbacks> callbacks,
     scoped_ptr<IndexedDBConnection> connection,
     int64 transaction_id,
     int64 requested_version,
-    WebKit::WebIDBCallbacks::DataLoss data_loss,
+    blink::WebIDBCallbacks::DataLoss data_loss,
     std::string data_loss_message) {
 
   std::vector<int64> object_store_ids;
   CreateTransaction(transaction_id,
                     connection.get(),
                     object_store_ids,
                     indexed_db::TRANSACTION_VERSION_CHANGE);
   scoped_refptr<IndexedDBTransaction> transaction =
       transactions_[transaction_id];
 
@@ skipping 38 matching lines @@
 bool IndexedDBDatabase::IsDeleteDatabaseBlocked() const {
   return !!ConnectionCount();
 }
 
 void IndexedDBDatabase::DeleteDatabaseFinal(
     scoped_refptr<IndexedDBCallbacks> callbacks) {
   DCHECK(!IsDeleteDatabaseBlocked());
   DCHECK(backing_store_);
   if (!backing_store_->DeleteDatabase(metadata_.name)) {
     callbacks->OnError(
-        IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionUnknownError,
+        IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError,
                                "Internal error deleting database."));
     return;
   }
   metadata_.version = kNoStringVersion;
   metadata_.id = kInvalidId;
   metadata_.int_version = IndexedDBDatabaseMetadata::NO_INT_VERSION;
   metadata_.object_stores.clear();
   callbacks->OnSuccess();
 }
 
 void IndexedDBDatabase::Close(IndexedDBConnection* connection, bool forced) {
   DCHECK(connections_.count(connection));
   DCHECK(connection->IsConnected());
   DCHECK(connection->database() == this);
 
   // Abort outstanding transactions from the closing connection. This
   // can not happen if the close is requested by the connection itself
   // as the front-end defers the close until all transactions are
   // complete, but can occur on process termination or forced close.
   {
     TransactionMap transactions(transactions_);
     for (TransactionMap::const_iterator it = transactions.begin(),
                                         end = transactions.end();
          it != end;
          ++it) {
       if (it->second->connection() == connection->callbacks())
         it->second->Abort(
-            IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionUnknownError,
+            IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError,
                                    "Connection is closing."));
     }
   }
 
   connections_.erase(connection);
   if (pending_second_half_open_ &&
       pending_second_half_open_->Connection() == connection) {
     pending_second_half_open_->Callbacks()->OnError(
-        IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionAbortError,
+        IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionAbortError,
                                "The connection was closed."));
     pending_second_half_open_.reset();
   }
 
   ProcessPendingCalls();
 
   // TODO(jsbell): Add a test for the pending_open_calls_ cases below.
   if (!ConnectionCount() && !pending_open_calls_.size() &&
       !pending_delete_calls_.size()) {
     DCHECK(transactions_.empty());
@@ skipping 31 matching lines @@
     const string16& previous_version,
     int64 previous_int_version,
     IndexedDBTransaction* transaction) {
   IDB_TRACE("IndexedDBDatabase::VersionChangeAbortOperation");
   DCHECK(!transaction);
   metadata_.version = previous_version;
   metadata_.int_version = previous_int_version;
 }
 
 }  // namespace content