Rename IDBRequest::On* callbacks to IDBRequest::Enqueue*.

third_party/WebKit/Source/modules/indexeddb/IDBRequest.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 145 matching lines @@
 
   EventQueue* event_queue = GetExecutionContext()->GetEventQueue();
   for (size_t i = 0; i < enqueued_events_.size(); ++i) {
     bool removed = event_queue->CancelEvent(enqueued_events_[i].Get());
     DCHECK(removed);
   }
   enqueued_events_.clear();
 
   error_.Clear();
   result_.Clear();
-  OnError(DOMException::Create(
+  EnqueueResponse(DOMException::Create(
       kAbortError,
       "The transaction was aborted, so the request cannot be fulfilled."));
   request_aborted_ = true;
 }
 
 void IDBRequest::SetCursorDetails(IndexedDB::CursorType cursor_type,
                                   WebIDBCursorDirection direction) {
   DCHECK_EQ(ready_state_, PENDING);
   DCHECK(!pending_cursor_);
   cursor_type_ = cursor_type;
@@ skipping 28 matching lines @@
 void IDBRequest::SetResultCursor(IDBCursor* cursor,
                                  IDBKey* key,
                                  IDBKey* primary_key,
                                  PassRefPtr<IDBValue> value) {
   DCHECK_EQ(ready_state_, PENDING);
   cursor_key_ = key;
   cursor_primary_key_ = primary_key;
   cursor_value_ = std::move(value);
   AckReceivedBlobs(cursor_value_.Get());
 
-  OnSuccessInternal(IDBAny::Create(cursor));
+  EnqueueResultInternal(IDBAny::Create(cursor));
 }
 
 void IDBRequest::AckReceivedBlobs(const IDBValue* value) {
   if (!transaction_ || !transaction_->BackendDB())
     return;
   Vector<String> uuids = value->GetUUIDs();
   if (!uuids.IsEmpty())
     transaction_->BackendDB()->AckReceivedBlobs(uuids);
 }
 
 void IDBRequest::AckReceivedBlobs(const Vector<RefPtr<IDBValue>>& values) {
   for (size_t i = 0; i < values.size(); ++i)
     AckReceivedBlobs(values[i].Get());
 }
 
 bool IDBRequest::ShouldEnqueueEvent() const {
   if (!GetExecutionContext())
     return false;
   DCHECK(ready_state_ == PENDING || ready_state_ == DONE);
   if (request_aborted_)
     return false;
   DCHECK_EQ(ready_state_, PENDING);
   DCHECK(!error_ && !result_);
   return true;
 }
 
-void IDBRequest::OnError(DOMException* error) {
+void IDBRequest::EnqueueResponse(DOMException* error) {
   IDB_TRACE("IDBRequest::onError()");
   ClearPutOperationBlobs();
   if (!ShouldEnqueueEvent())
     return;
 
   error_ = error;
   SetResult(IDBAny::CreateUndefined());
   pending_cursor_.Clear();
   EnqueueEvent(Event::CreateCancelableBubble(EventTypeNames::error));
 }
 
-void IDBRequest::OnSuccess(const Vector<String>& string_list) {
+void IDBRequest::EnqueueResponse(const Vector<String>& string_list) {
   IDB_TRACE("IDBRequest::onSuccess(StringList)");
   if (!ShouldEnqueueEvent())
     return;
 
   DOMStringList* dom_string_list = DOMStringList::Create();
   for (size_t i = 0; i < string_list.size(); ++i)
     dom_string_list->Append(string_list[i]);
-  OnSuccessInternal(IDBAny::Create(dom_string_list));
+  EnqueueResultInternal(IDBAny::Create(dom_string_list));
 }
 
-void IDBRequest::OnSuccess(std::unique_ptr<WebIDBCursor> backend,
-                           IDBKey* key,
-                           IDBKey* primary_key,
-                           PassRefPtr<IDBValue> value) {
+void IDBRequest::EnqueueResponse(std::unique_ptr<WebIDBCursor> backend,
+                                 IDBKey* key,
+                                 IDBKey* primary_key,
+                                 PassRefPtr<IDBValue> value) {
   IDB_TRACE("IDBRequest::onSuccess(IDBCursor)");
   if (!ShouldEnqueueEvent())
     return;
 
   DCHECK(!pending_cursor_);
   IDBCursor* cursor = nullptr;
   switch (cursor_type_) {
     case IndexedDB::kCursorKeyOnly:
       cursor = IDBCursor::Create(std::move(backend), cursor_direction_, this,
                                  source_.Get(), transaction_.Get());
       break;
     case IndexedDB::kCursorKeyAndValue:
       cursor =
           IDBCursorWithValue::Create(std::move(backend), cursor_direction_,
                                      this, source_.Get(), transaction_.Get());
       break;
     default:
       NOTREACHED();
   }
   SetResultCursor(cursor, key, primary_key, std::move(value));
 }
 
-void IDBRequest::OnSuccess(IDBKey* idb_key) {
+void IDBRequest::EnqueueResponse(IDBKey* idb_key) {
   IDB_TRACE("IDBRequest::onSuccess(IDBKey)");
   ClearPutOperationBlobs();
   if (!ShouldEnqueueEvent())
     return;
 
   if (idb_key && idb_key->IsValid())
-    OnSuccessInternal(IDBAny::Create(idb_key));
+    EnqueueResultInternal(IDBAny::Create(idb_key));
   else
-    OnSuccessInternal(IDBAny::CreateUndefined());
+    EnqueueResultInternal(IDBAny::CreateUndefined());
 }
 
-void IDBRequest::OnSuccess(const Vector<RefPtr<IDBValue>>& values) {
+void IDBRequest::EnqueueResponse(const Vector<RefPtr<IDBValue>>& values) {
   IDB_TRACE("IDBRequest::onSuccess([IDBValue])");
   if (!ShouldEnqueueEvent())
     return;
 
   AckReceivedBlobs(values);
-  OnSuccessInternal(IDBAny::Create(values));
+  EnqueueResultInternal(IDBAny::Create(values));
 }
 
 #if DCHECK_IS_ON()
 static IDBObjectStore* EffectiveObjectStore(IDBAny* source) {
   if (source->GetType() == IDBAny::kIDBObjectStoreType)
     return source->IdbObjectStore();
   if (source->GetType() == IDBAny::kIDBIndexType)
     return source->IdbIndex()->objectStore();
 
   NOTREACHED();
   return nullptr;
 }
 #endif  // DCHECK_IS_ON()
 
-void IDBRequest::OnSuccess(PassRefPtr<IDBValue> prp_value) {
+void IDBRequest::EnqueueResponse(PassRefPtr<IDBValue> prp_value) {
   IDB_TRACE("IDBRequest::onSuccess(IDBValue)");
   if (!ShouldEnqueueEvent())
     return;
 
   RefPtr<IDBValue> value(std::move(prp_value));
   AckReceivedBlobs(value.Get());
 
   if (pending_cursor_) {
     // Value should be null, signifying the end of the cursor's range.
     DCHECK(value->IsNull());
     DCHECK(!value->BlobInfo()->size());
     pending_cursor_->Close();
     pending_cursor_.Clear();
   }
 
 #if DCHECK_IS_ON()
   DCHECK(!value->PrimaryKey() ||
          value->KeyPath() == EffectiveObjectStore(source_)->IdbKeyPath());
 #endif
 
-  OnSuccessInternal(IDBAny::Create(value.Release()));
+  EnqueueResultInternal(IDBAny::Create(value.Release()));
 }
 
-void IDBRequest::OnSuccess(int64_t value) {
+void IDBRequest::EnqueueResponse(int64_t value) {
   IDB_TRACE("IDBRequest::onSuccess(int64_t)");
   if (!ShouldEnqueueEvent())
     return;
-  OnSuccessInternal(IDBAny::Create(value));
+  EnqueueResultInternal(IDBAny::Create(value));
 }
 
-void IDBRequest::OnSuccess() {
+void IDBRequest::EnqueueResponse() {
   IDB_TRACE("IDBRequest::onSuccess()");
   if (!ShouldEnqueueEvent())
     return;
-  OnSuccessInternal(IDBAny::CreateUndefined());
+  EnqueueResultInternal(IDBAny::CreateUndefined());
 }
 
-void IDBRequest::OnSuccessInternal(IDBAny* result) {
+void IDBRequest::EnqueueResultInternal(IDBAny* result) {
   DCHECK(GetExecutionContext());
   DCHECK(!pending_cursor_);
   DCHECK(transit_blob_handles_.IsEmpty());
   SetResult(result);
   EnqueueEvent(Event::Create(EventTypeNames::success));
 }
 
 void IDBRequest::SetResult(IDBAny* result) {
   result_ = result;
   result_dirty_ = true;
 }
 
-void IDBRequest::OnSuccess(IDBKey* key,
-                           IDBKey* primary_key,
-                           PassRefPtr<IDBValue> value) {
+void IDBRequest::EnqueueResponse(IDBKey* key,
+                                 IDBKey* primary_key,
+                                 PassRefPtr<IDBValue> value) {
   IDB_TRACE("IDBRequest::onSuccess(key, primaryKey, value)");
   if (!ShouldEnqueueEvent())
     return;
 
   DCHECK(pending_cursor_);
   SetResultCursor(pending_cursor_.Release(), key, primary_key,
                   std::move(value));
 }
 
 bool IDBRequest::HasPendingActivity() const {
@@ skipping 168 matching lines @@
 }
 
 void IDBRequest::DequeueEvent(Event* event) {
   for (size_t i = 0; i < enqueued_events_.size(); ++i) {
     if (enqueued_events_[i].Get() == event)
       enqueued_events_.erase(i);
   }
 }
 
 }  // namespace blink