IndexedDB: Rename OpenOrDeleteRequest class to ConnectionRequest

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 <limits>
 #include <memory>
@@ skipping 65 matching lines @@
   NOTREACHED();
   return KEY_PATH_TYPE_NONE;
 }
 
 }  // namespace
 
 // This represents what script calls an 'IDBOpenDBRequest' - either a database
 // open or delete call. These may be blocked on other connections. After every
 // callback, the request must call IndexedDBDatabase::RequestComplete() or be
 // expecting a further callback.
-class IndexedDBDatabase::OpenOrDeleteRequest {
+class IndexedDBDatabase::ConnectionRequest {
  public:
-  explicit OpenOrDeleteRequest(scoped_refptr<IndexedDBDatabase> db) : db_(db) {}
+  explicit ConnectionRequest(scoped_refptr<IndexedDBDatabase> db) : db_(db) {}
 
-  virtual ~OpenOrDeleteRequest() {}
+  virtual ~ConnectionRequest() {}
 
   // Called when the request makes it to the front of the queue.
   virtual void Perform() = 0;
 
   // Called if a front-end signals that it is ignoring a "versionchange"
   // event. This should result in firing a "blocked" event at the request.
   virtual void OnVersionChangeIgnored() const = 0;
 
   // Called when a connection is closed; if it corresponds to this connection,
   // need to do cleanup. Otherwise, it may unblock further steps.
   virtual void OnConnectionClosed(IndexedDBConnection* connection) = 0;
 
   // Called when the upgrade transaction has started executing.
   virtual void UpgradeTransactionStarted(int64_t old_version) = 0;
 
   // Called when the upgrade transaction has finished.
   virtual void UpgradeTransactionFinished(bool committed) = 0;
 
  protected:
   scoped_refptr<IndexedDBDatabase> db_;
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(OpenOrDeleteRequest);
+  DISALLOW_COPY_AND_ASSIGN(ConnectionRequest);
 };
 
 class IndexedDBDatabase::OpenRequest
-    : public IndexedDBDatabase::OpenOrDeleteRequest {
+    : public IndexedDBDatabase::ConnectionRequest {
  public:
   OpenRequest(scoped_refptr<IndexedDBDatabase> db,
               std::unique_ptr<IndexedDBPendingConnection> pending_connection)
-      : OpenOrDeleteRequest(db), pending_(std::move(pending_connection)) {}
+      : ConnectionRequest(db), pending_(std::move(pending_connection)) {}
 
   void Perform() override {
     if (db_->metadata_.id == kInvalidId) {
       // The database was deleted then immediately re-opened; OpenInternal()
       // recreates it in the backing store.
       if (!db_->OpenInternal().ok()) {
         // TODO(jsbell): Consider including sanitized leveldb status message.
         base::string16 message;
         if (pending_->version == IndexedDBDatabaseMetadata::NO_VERSION) {
           message = ASCIIToUTF16(
@@ skipping 147 matching lines @@
   std::unique_ptr<IndexedDBPendingConnection> pending_;
 
   // If an upgrade is needed, holds the pending connection until ownership is
   // transferred to the IndexedDBDispatcherHost via OnUpgradeNeeded.
   std::unique_ptr<IndexedDBConnection> connection_;
 
   DISALLOW_COPY_AND_ASSIGN(OpenRequest);
 };
 
 class IndexedDBDatabase::DeleteRequest
-    : public IndexedDBDatabase::OpenOrDeleteRequest {
+    : public IndexedDBDatabase::ConnectionRequest {
  public:
   DeleteRequest(scoped_refptr<IndexedDBDatabase> db,
                 scoped_refptr<IndexedDBCallbacks> callbacks)
-      : OpenOrDeleteRequest(db), callbacks_(callbacks) {}
+      : ConnectionRequest(db), callbacks_(callbacks) {}
 
   void Perform() override {
     if (db_->connections_.empty()) {
       // No connections, so delete immediately.
       DoDelete();
       return;
     }
 
     // Front end ensures the event is not fired at connections that have
     // close_pending set.
@@ skipping 1542 matching lines @@
   if (status.IsCorruption()) {
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Error committing transaction");
     factory_->HandleBackingStoreCorruption(backing_store_->origin(), error);
   } else {
     factory_->HandleBackingStoreFailure(backing_store_->origin());
   }
 }
 
 void IndexedDBDatabase::AppendRequest(
-    std::unique_ptr<OpenOrDeleteRequest> request) {
+    std::unique_ptr<ConnectionRequest> request) {
   pending_requests_.push(std::move(request));
 
   if (!active_request_)
     ProcessRequestQueue();
 }
 
-void IndexedDBDatabase::RequestComplete(OpenOrDeleteRequest* request) {
+void IndexedDBDatabase::RequestComplete(ConnectionRequest* request) {
   DCHECK_EQ(request, active_request_.get());
   active_request_.reset();
 
   if (!pending_requests_.empty())
     ProcessRequestQueue();
 }
 
 void IndexedDBDatabase::ProcessRequestQueue() {
   // Don't run re-entrantly to avoid exploding call stacks for requests that
   // complete synchronously. The loop below will process requests until one is
@@ skipping 130 matching lines @@
 
 void IndexedDBDatabase::VersionChangeAbortOperation(
     int64_t previous_version,
     IndexedDBTransaction* transaction) {
   DCHECK(!transaction);
   IDB_TRACE("IndexedDBDatabase::VersionChangeAbortOperation");
   metadata_.version = previous_version;
 }
 
 }  // namespace content