Remove IDBCursorBackendInterface::deleteFunction (part 2/3)

content/common_child/indexed_db/indexed_db_dispatcher.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/common_child/indexed_db/indexed_db_dispatcher.h"
 
 #include "base/format_macros.h"
 #include "base/lazy_instance.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread_local.h"
@@ skipping 59 matching lines @@
   }
   if (g_idb_dispatcher_tls.Pointer()->Get())
     return g_idb_dispatcher_tls.Pointer()->Get();
 
   IndexedDBDispatcher* dispatcher = new IndexedDBDispatcher;
   if (WorkerTaskRunner::Instance()->CurrentWorkerId())
     webkit_glue::WorkerTaskRunner::Instance()->AddStopObserver(dispatcher);
   return dispatcher;
 }
 
-void IndexedDBDispatcher::OnWorkerRunLoopStopped() {
-  delete this;
-}
+void IndexedDBDispatcher::OnWorkerRunLoopStopped() { delete this; }

[jsbell, 2013/06/03 17:52:27]

more clang-format...

 
 WebIDBMetadata IndexedDBDispatcher::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());
+  web_metadata.objectStores =
+      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.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());
+    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];
+      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.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;
   IPC_BEGIN_MESSAGE_MAP(IndexedDBDispatcher, msg)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksSuccessIDBCursor,
                         OnSuccessOpenCursor)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksSuccessCursorAdvance,
                         OnSuccessCursorContinue)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksSuccessCursorContinue,
                         OnSuccessCursorContinue)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksSuccessCursorPrefetch,
                         OnSuccessCursorPrefetch)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksSuccessIDBDatabase,
                         OnSuccessIDBDatabase)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksSuccessIndexedDBKey,
                         OnSuccessIndexedDBKey)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksSuccessStringList,
                         OnSuccessStringList)
-    IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksSuccessValue,
-                        OnSuccessValue)
+    IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksSuccessValue, OnSuccessValue)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksSuccessValueWithKey,
                         OnSuccessValueWithKey)
-    IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksSuccessInteger,
-                        OnSuccessInteger)
+    IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksSuccessInteger, OnSuccessInteger)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksSuccessUndefined,
                         OnSuccessUndefined)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksError, OnError)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksIntBlocked, OnIntBlocked)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_CallbacksUpgradeNeeded, OnUpgradeNeeded)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_DatabaseCallbacksForcedClose,
                         OnForcedClose)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_DatabaseCallbacksIntVersionChange,
                         OnIntVersionChange)
     IPC_MESSAGE_HANDLER(IndexedDBMsg_DatabaseCallbacksAbort, OnAbort)
@@ skipping 23 matching lines @@
 void IndexedDBDispatcher::RequestIDBCursorAdvance(
     unsigned long count,
     WebIDBCallbacks* callbacks_ptr,
     int32 ipc_cursor_id) {
   // Reset all cursor prefetch caches except for this cursor.
   ResetCursorPrefetchCaches(ipc_cursor_id);
 
   scoped_ptr<WebIDBCallbacks> callbacks(callbacks_ptr);
 
   int32 ipc_callbacks_id = pending_callbacks_.Add(callbacks.release());
-  Send(new IndexedDBHostMsg_CursorAdvance(ipc_cursor_id, CurrentWorkerId(),
-                                          ipc_callbacks_id, count));
+  Send(new IndexedDBHostMsg_CursorAdvance(
+      ipc_cursor_id, CurrentWorkerId(), ipc_callbacks_id, count));
 }
 
 void IndexedDBDispatcher::RequestIDBCursorContinue(
     const IndexedDBKey& key,
     WebIDBCallbacks* callbacks_ptr,
     int32 ipc_cursor_id) {
   // Reset all cursor prefetch caches except for this cursor.
   ResetCursorPrefetchCaches(ipc_cursor_id);
 
   scoped_ptr<WebIDBCallbacks> callbacks(callbacks_ptr);
 
   int32 ipc_callbacks_id = pending_callbacks_.Add(callbacks.release());
-  Send(
-      new IndexedDBHostMsg_CursorContinue(ipc_cursor_id, CurrentWorkerId(),
-                                          ipc_callbacks_id, key));
+  Send(new IndexedDBHostMsg_CursorContinue(
+      ipc_cursor_id, CurrentWorkerId(), ipc_callbacks_id, key));
 }
 
 void IndexedDBDispatcher::RequestIDBCursorPrefetch(
     int n,
     WebIDBCallbacks* callbacks_ptr,
     int32 ipc_cursor_id) {
   scoped_ptr<WebIDBCallbacks> callbacks(callbacks_ptr);
 
   int32 ipc_callbacks_id = pending_callbacks_.Add(callbacks.release());
-  Send(new IndexedDBHostMsg_CursorPrefetch(ipc_cursor_id, CurrentWorkerId(),
-                                           ipc_callbacks_id, n));
+  Send(new IndexedDBHostMsg_CursorPrefetch(
+      ipc_cursor_id, CurrentWorkerId(), ipc_callbacks_id, n));
 }
 
-void IndexedDBDispatcher::RequestIDBCursorPrefetchReset(
-    int used_prefetches, int unused_prefetches, int32 ipc_cursor_id) {
-  Send(new IndexedDBHostMsg_CursorPrefetchReset(ipc_cursor_id,
-                                                used_prefetches,
-                                                unused_prefetches));
-}
-
-void IndexedDBDispatcher::RequestIDBCursorDelete(

[jsbell, 2013/06/03 17:52:27]

This is the only real change in the file.

-    WebIDBCallbacks* callbacks_ptr,
-    int32 ipc_cursor_id) {
-  ResetCursorPrefetchCaches();
-  scoped_ptr<WebIDBCallbacks> callbacks(callbacks_ptr);
-
-  int32 ipc_callbacks_id = pending_callbacks_.Add(callbacks.release());
-  Send(new IndexedDBHostMsg_CursorDelete(ipc_cursor_id, CurrentWorkerId(),
-                                         ipc_callbacks_id));
+void IndexedDBDispatcher::RequestIDBCursorPrefetchReset(int used_prefetches,
+                                                        int unused_prefetches,
+                                                        int32 ipc_cursor_id) {
+  Send(new IndexedDBHostMsg_CursorPrefetchReset(
+      ipc_cursor_id, used_prefetches, unused_prefetches));
 }
 
 void IndexedDBDispatcher::RequestIDBFactoryOpen(
     const string16& name,
     int64 version,
     int64 transaction_id,
     WebIDBCallbacks* callbacks_ptr,
     WebIDBDatabaseCallbacks* database_callbacks_ptr,
     const string16& database_identifier) {
   ResetCursorPrefetchCaches();
   scoped_ptr<WebIDBCallbacks> callbacks(callbacks_ptr);
-  scoped_ptr<WebIDBDatabaseCallbacks>
-      database_callbacks(database_callbacks_ptr);
+  scoped_ptr<WebIDBDatabaseCallbacks> database_callbacks(
+      database_callbacks_ptr);
 
   IndexedDBHostMsg_FactoryOpen_Params params;
   params.ipc_thread_id = CurrentWorkerId();
   params.ipc_callbacks_id = pending_callbacks_.Add(callbacks.release());
-  params.ipc_database_callbacks_id = pending_database_callbacks_.Add(
-      database_callbacks.release());
+  params.ipc_database_callbacks_id =
+      pending_database_callbacks_.Add(database_callbacks.release());
   params.database_identifier = database_identifier;
   params.name = name;
   params.transaction_id = transaction_id;
   params.version = version;
   Send(new IndexedDBHostMsg_FactoryOpen(params));
 }
 
 void IndexedDBDispatcher::RequestIDBFactoryGetDatabaseNames(
     WebIDBCallbacks* callbacks_ptr,
     const string16& database_identifier) {
@@ skipping 32 matching lines @@
   if (pending_database_callbacks_.Lookup(ipc_database_callbacks_id))
     pending_database_callbacks_.Remove(ipc_database_callbacks_id);
 }
 
 void IndexedDBDispatcher::RequestIDBDatabaseCreateTransaction(
     int32 ipc_database_id,
     int64 transaction_id,
     WebIDBDatabaseCallbacks* database_callbacks_ptr,
     WebKit::WebVector<long long> object_store_ids,
     unsigned short mode) {
-  scoped_ptr<WebIDBDatabaseCallbacks>
-      database_callbacks(database_callbacks_ptr);
+  scoped_ptr<WebIDBDatabaseCallbacks> database_callbacks(
+      database_callbacks_ptr);
   IndexedDBHostMsg_DatabaseCreateTransaction_Params params;
   params.ipc_thread_id = CurrentWorkerId();
   params.ipc_database_id = ipc_database_id;
   params.transaction_id = transaction_id;
-  params.ipc_database_callbacks_id = pending_database_callbacks_.Add(
-      database_callbacks.release());
-  params.object_store_ids.assign(object_store_ids.data(),
-                                 object_store_ids.data() +
-                                 object_store_ids.size());
+  params.ipc_database_callbacks_id =
+      pending_database_callbacks_.Add(database_callbacks.release());
+  params.object_store_ids
+      .assign(object_store_ids.data(),
+              object_store_ids.data() + object_store_ids.size());
   params.mode = mode;
 
   Send(new IndexedDBHostMsg_DatabaseCreateTransaction(params));
 }
 
-
 void IndexedDBDispatcher::RequestIDBDatabaseGet(
     int32 ipc_database_id,
     int64 transaction_id,
     int64 object_store_id,
     int64 index_id,
     const IndexedDBKeyRange& key_range,
     bool key_only,
     WebIDBCallbacks* callbacks) {
   ResetCursorPrefetchCaches();
   IndexedDBHostMsg_DatabaseGet_Params params;
   init_params(params, callbacks);
   params.ipc_database_id = ipc_database_id;
   params.transaction_id = transaction_id;
   params.object_store_id = object_store_id;
   params.index_id = index_id;
   params.key_range = key_range;
   params.key_only = key_only;
   Send(new IndexedDBHostMsg_DatabaseGet(params));
 }
 
-
 void IndexedDBDispatcher::RequestIDBDatabasePut(
     int32 ipc_database_id,
     int64 transaction_id,
     int64 object_store_id,
     const WebData& value,
     const IndexedDBKey& key,
     WebIDBDatabase::PutMode put_mode,
     WebIDBCallbacks* callbacks,
     const WebVector<long long>& index_ids,
-    const WebVector<WebKit::WebVector<
-      WebIDBKey> >& index_keys) {
+    const WebVector<WebKit::WebVector<WebIDBKey> >& index_keys) {
 
   if (value.size() > kMaxIDBValueSizeInBytes) {
     callbacks->onError(WebIDBDatabaseError(
         WebKit::WebIDBDatabaseExceptionUnknownError,
-        WebString::fromUTF8(
-            base::StringPrintf(
-                "The serialized value is too large"
-                " (size=%" PRIuS " bytes, max=%" PRIuS " bytes).",
-                value.size(), kMaxIDBValueSizeInBytes).c_str())));
+        WebString::fromUTF8(base::StringPrintf(
+            "The serialized value is too large"
+            " (size=%" PRIuS " bytes, max=%" PRIuS " bytes).",
+            value.size(),
+            kMaxIDBValueSizeInBytes).c_str())));
     return;
   }
 
   ResetCursorPrefetchCaches();
   IndexedDBHostMsg_DatabasePut_Params params;
   init_params(params, callbacks);
   params.ipc_database_id = ipc_database_id;
   params.transaction_id = transaction_id;
   params.object_store_id = object_store_id;
 
   params.value.assign(value.data(), value.data() + value.size());
   params.key = key;
   params.put_mode = put_mode;
 
-  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());
+  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].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]);
+    }
   }
   Send(new IndexedDBHostMsg_DatabasePut(params));
 }
 
 void IndexedDBDispatcher::RequestIDBDatabaseOpenCursor(
     int32 ipc_database_id,
     int64 transaction_id,
     int64 object_store_id,
     int64 index_id,
     const IndexedDBKeyRange& key_range,
@@ skipping 31 matching lines @@
   params.index_id = index_id;
   params.key_range = IndexedDBKeyRange(key_range);
   Send(new IndexedDBHostMsg_DatabaseCount(params));
 }
 
 void IndexedDBDispatcher::RequestIDBDatabaseDeleteRange(
     int32 ipc_database_id,
     int64 transaction_id,
     int64 object_store_id,
     const IndexedDBKeyRange& key_range,
-    WebKit::WebIDBCallbacks* callbacks)
-{
+    WebKit::WebIDBCallbacks* callbacks) {
   ResetCursorPrefetchCaches();
   IndexedDBHostMsg_DatabaseDeleteRange_Params params;
   init_params(params, callbacks);
   params.ipc_database_id = ipc_database_id;
   params.transaction_id = transaction_id;
   params.object_store_id = object_store_id;
   params.key_range = key_range;
   Send(new IndexedDBHostMsg_DatabaseDeleteRange(params));
 }
 
 void IndexedDBDispatcher::RequestIDBDatabaseClear(
     int32 ipc_database_id,
     int64 transaction_id,
     int64 object_store_id,
     WebKit::WebIDBCallbacks* callbacks_ptr) {
   scoped_ptr<WebIDBCallbacks> callbacks(callbacks_ptr);
   int32 ipc_callbacks_id = pending_callbacks_.Add(callbacks.release());
-  Send(new IndexedDBHostMsg_DatabaseClear(
-      CurrentWorkerId(), ipc_callbacks_id, ipc_database_id,
-      transaction_id, object_store_id));
+  Send(new IndexedDBHostMsg_DatabaseClear(CurrentWorkerId(),
+                                          ipc_callbacks_id,
+                                          ipc_database_id,
+                                          transaction_id,
+                                          object_store_id));
 }
 
 void IndexedDBDispatcher::CursorDestroyed(int32 ipc_cursor_id) {
   cursors_.erase(ipc_cursor_id);
 }
 
 void IndexedDBDispatcher::DatabaseDestroyed(int32 ipc_database_id) {
   DCHECK_EQ(databases_.count(ipc_database_id), 1u);
   databases_.erase(ipc_database_id);
 }
@@ skipping 11 matching lines @@
   WebIDBMetadata metadata(ConvertMetadata(idb_metadata));
   // If an upgrade was performed, count will be non-zero.
   if (!databases_.count(ipc_object_id))
     databases_[ipc_object_id] = new RendererWebIDBDatabaseImpl(
         ipc_object_id, ipc_database_callbacks_id);
   DCHECK_EQ(databases_.count(ipc_object_id), 1u);
   callbacks->onSuccess(databases_[ipc_object_id], metadata);
   pending_callbacks_.Remove(ipc_callbacks_id);
 }
 
-void IndexedDBDispatcher::OnSuccessIndexedDBKey(
-    int32 ipc_thread_id,
-    int32 ipc_callbacks_id,
-    const IndexedDBKey& key) {
+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));
   pending_callbacks_.Remove(ipc_callbacks_id);
 }
 
 void IndexedDBDispatcher::OnSuccessStringList(
-    int32 ipc_thread_id, int32 ipc_callbacks_id,
+    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)
     return;
   callbacks->onSuccess(WebVector<WebString>(value));
   pending_callbacks_.Remove(ipc_callbacks_id);
 }
 
-void IndexedDBDispatcher::OnSuccessValue(
-    int32 ipc_thread_id, int32 ipc_callbacks_id,
-    const std::vector<char>& value) {
+void IndexedDBDispatcher::OnSuccessValue(int32 ipc_thread_id,
+                                         int32 ipc_callbacks_id,
+                                         const std::vector<char>& value) {
   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.front(), value.size());
+    web_value.assign(&value.front(), value.size());
   callbacks->onSuccess(web_value);
   pending_callbacks_.Remove(ipc_callbacks_id);
 }
 
 void IndexedDBDispatcher::OnSuccessValueWithKey(
-    int32 ipc_thread_id, int32 ipc_callbacks_id,
+    int32 ipc_thread_id,
+    int32 ipc_callbacks_id,
     const std::vector<char>& 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.front(), value.size());
-  callbacks->onSuccess(web_value,
-                       primary_key, key_path);
+    web_value.assign(&value.front(), value.size());
+  callbacks->onSuccess(web_value, primary_key, key_path);
   pending_callbacks_.Remove(ipc_callbacks_id);
 }
 
-void IndexedDBDispatcher::OnSuccessInteger(
-    int32 ipc_thread_id, int32 ipc_callbacks_id, int64 value) {
+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;
   callbacks->onSuccess(value);
   pending_callbacks_.Remove(ipc_callbacks_id);
 }
 
-void IndexedDBDispatcher::OnSuccessUndefined(
-    int32 ipc_thread_id, int32 ipc_callbacks_id) {
+void IndexedDBDispatcher::OnSuccessUndefined(int32 ipc_thread_id,
+                                             int32 ipc_callbacks_id) {
   DCHECK_EQ(ipc_thread_id, CurrentWorkerId());
   WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(ipc_callbacks_id);
   if (!callbacks)
     return;
   callbacks->onSuccess();
   pending_callbacks_.Remove(ipc_callbacks_id);
 }
 
 void IndexedDBDispatcher::OnSuccessOpenCursor(
     const IndexedDBMsg_CallbacksSuccessIDBCursor_Params& p) {
   DCHECK_EQ(p.ipc_thread_id, CurrentWorkerId());
   int32 ipc_callbacks_id = p.ipc_callbacks_id;
   int32 ipc_object_id = p.ipc_cursor_id;
   const IndexedDBKey& key = p.key;
   const IndexedDBKey& primary_key = p.primary_key;
   WebData web_value;
   if (p.value.size())
-      web_value.assign(&p.value.front(), p.value.size());
+    web_value.assign(&p.value.front(), p.value.size());
 
-  WebIDBCallbacks* callbacks =
-      pending_callbacks_.Lookup(ipc_callbacks_id);
+  WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(ipc_callbacks_id);
   if (!callbacks)
     return;
 
   RendererWebIDBCursorImpl* cursor =
-          new RendererWebIDBCursorImpl(ipc_object_id);
+      new RendererWebIDBCursorImpl(ipc_object_id);
   cursors_[ipc_object_id] = cursor;
   callbacks->onSuccess(cursor, key, 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::vector<char>& 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.front(), value.size());
+    web_value.assign(&value.front(), value.size());
   callbacks->onSuccess(key, 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;
   const std::vector<IndexedDBKey>& primary_keys = p.primary_keys;
   std::vector<WebData> values(p.values.size());
   for (size_t i = 0; i < p.values.size(); ++i) {
-      if (p.values[i].size())
-          values[i].assign(&p.values[i].front(), p.values[i].size());
+    if (p.values[i].size())
+      values[i].assign(&p.values[i].front(), p.values[i].size());
   }
   RendererWebIDBCursorImpl* cursor = cursors_[ipc_cursor_id];
   DCHECK(cursor);
   cursor->SetPrefetchData(keys, primary_keys, values);
 
   WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(ipc_callbacks_id);
   DCHECK(callbacks);
   cursor->CachedContinue(callbacks);
   pending_callbacks_.Remove(ipc_callbacks_id);
 }
@@ skipping 10 matching lines @@
 void IndexedDBDispatcher::OnUpgradeNeeded(
     const IndexedDBMsg_CallbacksUpgradeNeeded_Params& p) {
   DCHECK_EQ(p.ipc_thread_id, CurrentWorkerId());
   WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(p.ipc_callbacks_id);
   DCHECK(callbacks);
   WebIDBMetadata metadata(ConvertMetadata(p.idb_metadata));
   DCHECK(!databases_.count(p.ipc_database_id));
   databases_[p.ipc_database_id] = new RendererWebIDBDatabaseImpl(
       p.ipc_database_id, p.ipc_database_callbacks_id);
   callbacks->onUpgradeNeeded(
-      p.old_version,
-      databases_[p.ipc_database_id],
-      metadata);
+      p.old_version, databases_[p.ipc_database_id], metadata);
 }
 
 void IndexedDBDispatcher::OnError(int32 ipc_thread_id,
                                   int32 ipc_callbacks_id,
                                   int code,
                                   const string16& message) {
   DCHECK_EQ(ipc_thread_id, CurrentWorkerId());
   WebIDBCallbacks* callbacks = pending_callbacks_.Lookup(ipc_callbacks_id);
   if (!callbacks)
     return;
   callbacks->onError(WebIDBDatabaseError(code, message));
   pending_callbacks_.Remove(ipc_callbacks_id);
 }
 
 void IndexedDBDispatcher::OnAbort(int32 ipc_thread_id,
                                   int32 ipc_database_callbacks_id,
                                   int64 transaction_id,
-                                  int code, const string16& message) {
+                                  int code,
+                                  const string16& message) {
   DCHECK_EQ(ipc_thread_id, CurrentWorkerId());
   WebIDBDatabaseCallbacks* callbacks =
       pending_database_callbacks_.Lookup(ipc_database_callbacks_id);
   if (!callbacks)
     return;
   callbacks->onAbort(transaction_id, WebIDBDatabaseError(code, message));
 }
 
 void IndexedDBDispatcher::OnComplete(int32 ipc_thread_id,
                                      int32 ipc_database_callbacks_id,
@@ skipping 34 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