Replacing Indexed DB Chromium IPC with Mojo

content/browser/indexed_db/indexed_db_factory_impl.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_factory_impl.h"
 
 #include <stdint.h>
 
 #include <utility>
 #include <vector>
@@ skipping 409 matching lines @@
   std::string data_loss_message;
   bool disk_full = false;
   bool was_open = (it != database_map_.end());
   if (!was_open) {
     leveldb::Status s;
     scoped_refptr<IndexedDBBackingStore> backing_store =
         OpenBackingStore(origin, data_directory, request_context, &data_loss,
                          &data_loss_message, &disk_full, &s);
     if (!backing_store.get()) {
       if (disk_full) {
-        connection.callbacks->OnError(
-            IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionQuotaError,
-                                   ASCIIToUTF16(
-                                       "Encountered full disk while opening "
-                                       "backing store for indexedDB.open.")));
+        connection.OnError(IndexedDBDatabaseError(
+            blink::WebIDBDatabaseExceptionQuotaError,
+            ASCIIToUTF16("Encountered full disk while opening "
+                         "backing store for indexedDB.open.")));
         return;
       }
       IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                    ASCIIToUTF16(
                                        "Internal error opening backing store"
                                        " for indexedDB.open."));
-      connection.callbacks->OnError(error);
+      connection.OnError(error);
       if (s.IsCorruption()) {
         HandleBackingStoreCorruption(origin, error);
       }
       return;
     }
 
     database = IndexedDBDatabase::Create(
         name, backing_store.get(), this, unique_identifier, &s);
     if (!database.get()) {
       DLOG(ERROR) << "Unable to create the database";
       IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                    ASCIIToUTF16(
                                        "Internal error creating "
                                        "database backend for "
                                        "indexedDB.open."));
-      connection.callbacks->OnError(error);
+      connection.OnError(error);
       if (s.IsCorruption()) {
         backing_store = NULL;  // Closes the LevelDB so that it can be deleted
         HandleBackingStoreCorruption(origin, error);
       }
       return;
     }
   } else {
     database = it->second;
   }
 
   if (data_loss != blink::WebIDBDataLossNone)
-    connection.callbacks->OnDataLoss(data_loss, data_loss_message);
+    connection.OnDataLoss(data_loss, data_loss_message);
 
   database->OpenConnection(connection);
 
   if (!was_open && database->ConnectionCount() > 0) {
     database_map_[unique_identifier] = database.get();
     origin_dbs_.insert(std::make_pair(origin, database.get()));
   }
 }
 
 std::pair<IndexedDBFactoryImpl::OriginDBMapIterator,
           IndexedDBFactoryImpl::OriginDBMapIterator>
 IndexedDBFactoryImpl::GetOpenDatabasesForOrigin(const Origin& origin) const {
   return origin_dbs_.equal_range(origin);
 }
 
 size_t IndexedDBFactoryImpl::GetConnectionCount(const Origin& origin) const {
   size_t count(0);
 
   OriginDBs range = GetOpenDatabasesForOrigin(origin);
   for (OriginDBMapIterator it = range.first; it != range.second; ++it)
     count += it->second->ConnectionCount();
 
   return count;
 }
 
 }  // namespace content