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

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

 /*
  * Copyright (C) 2012 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 59 matching lines @@
 void IDBOpenDBRequest::ContextDestroyed(ExecutionContext* destroyed_context) {
   IDBRequest::ContextDestroyed(destroyed_context);
   if (database_callbacks_)
     database_callbacks_->DetachWebCallbacks();
 }
 
 const AtomicString& IDBOpenDBRequest::InterfaceName() const {
   return EventTargetNames::IDBOpenDBRequest;
 }
 
-void IDBOpenDBRequest::OnBlocked(int64_t old_version) {
+void IDBOpenDBRequest::EnqueueBlocked(int64_t old_version) {
   IDB_TRACE("IDBOpenDBRequest::onBlocked()");
   if (!ShouldEnqueueEvent())
     return;
   Nullable<unsigned long long> new_version_nullable =
       (version_ == IDBDatabaseMetadata::kDefaultVersion)
           ? Nullable<unsigned long long>()
           : Nullable<unsigned long long>(version_);
   EnqueueEvent(IDBVersionChangeEvent::Create(
       EventTypeNames::blocked, old_version, new_version_nullable));
 }
 
-void IDBOpenDBRequest::OnUpgradeNeeded(int64_t old_version,
-                                       std::unique_ptr<WebIDBDatabase> backend,
-                                       const IDBDatabaseMetadata& metadata,
-                                       WebIDBDataLoss data_loss,
-                                       String data_loss_message) {
+void IDBOpenDBRequest::EnqueueUpgradeNeeded(
+    int64_t old_version,
+    std::unique_ptr<WebIDBDatabase> backend,
+    const IDBDatabaseMetadata& metadata,
+    WebIDBDataLoss data_loss,
+    String data_loss_message) {
   IDB_TRACE("IDBOpenDBRequest::onUpgradeNeeded()");
   if (!ShouldEnqueueEvent())
     return;
 
   DCHECK(database_callbacks_);
 
   IDBDatabase* idb_database =
       IDBDatabase::Create(GetExecutionContext(), std::move(backend),
                           database_callbacks_.Release(), isolate_);
   idb_database->SetMetadata(metadata);
@@ skipping 10 matching lines @@
       old_database_metadata);
   SetResult(IDBAny::Create(idb_database));
 
   if (version_ == IDBDatabaseMetadata::kNoVersion)
     version_ = 1;
   EnqueueEvent(IDBVersionChangeEvent::Create(EventTypeNames::upgradeneeded,
                                              old_version, version_, data_loss,
                                              data_loss_message));
 }
 
-void IDBOpenDBRequest::OnSuccess(std::unique_ptr<WebIDBDatabase> backend,
-                                 const IDBDatabaseMetadata& metadata) {
+void IDBOpenDBRequest::EnqueueResponse(std::unique_ptr<WebIDBDatabase> backend,
+                                       const IDBDatabaseMetadata& metadata) {
   IDB_TRACE("IDBOpenDBRequest::onSuccess()");
   if (!ShouldEnqueueEvent())
     return;
 
   IDBDatabase* idb_database = nullptr;
   if (ResultAsAny()) {
     // Previous OnUpgradeNeeded call delivered the backend.
     DCHECK(!backend.get());
     idb_database = ResultAsAny()->IdbDatabase();
     DCHECK(idb_database);
     DCHECK(!database_callbacks_);
   } else {
     DCHECK(backend.get());
     DCHECK(database_callbacks_);
     idb_database =
         IDBDatabase::Create(GetExecutionContext(), std::move(backend),
                             database_callbacks_.Release(), isolate_);
     SetResult(IDBAny::Create(idb_database));
   }
   idb_database->SetMetadata(metadata);
   EnqueueEvent(Event::Create(EventTypeNames::success));
 }
 
-void IDBOpenDBRequest::OnSuccess(int64_t old_version) {
+void IDBOpenDBRequest::EnqueueResponse(int64_t old_version) {
   IDB_TRACE("IDBOpenDBRequest::onSuccess()");
   if (!ShouldEnqueueEvent())
     return;
   if (old_version == IDBDatabaseMetadata::kNoVersion) {
     // This database hasn't had an integer version before.
     old_version = IDBDatabaseMetadata::kDefaultVersion;
   }
   SetResult(IDBAny::CreateUndefined());
   EnqueueEvent(IDBVersionChangeEvent::Create(
       EventTypeNames::success, old_version, Nullable<unsigned long long>()));
 }
 
 bool IDBOpenDBRequest::ShouldEnqueueEvent() const {
   if (!GetExecutionContext())
     return false;
   DCHECK(ready_state_ == PENDING || ready_state_ == DONE);
   if (request_aborted_)
     return false;
   return true;
 }
 
 DispatchEventResult IDBOpenDBRequest::DispatchEventInternal(Event* event) {
   // If the connection closed between onUpgradeNeeded and the delivery of the
   // "success" event, an "error" event should be fired instead.
   if (event->type() == EventTypeNames::success &&
       ResultAsAny()->GetType() == IDBAny::kIDBDatabaseType &&
       ResultAsAny()->IdbDatabase()->IsClosePending()) {
     DequeueEvent(event);
     SetResult(nullptr);
-    OnError(DOMException::Create(kAbortError, "The connection was closed."));
+    EnqueueResponse(
+        DOMException::Create(kAbortError, "The connection was closed."));
     return DispatchEventResult::kCanceledBeforeDispatch;
   }
 
   return IDBRequest::DispatchEventInternal(event);
 }
 
 }  // namespace blink