[IndexedDB] Use consistent enums on both sides of IPC.

content/browser/indexed_db/indexed_db_transaction.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_transaction.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 36 matching lines @@
   DCHECK(!stack_.empty());
   Operation task(stack_.top());
   stack_.pop();
   return task;
 }
 
 IndexedDBTransaction::IndexedDBTransaction(
     int64 id,
     scoped_refptr<IndexedDBDatabaseCallbacks> callbacks,
     const std::set<int64>& object_store_ids,
-    indexed_db::TransactionMode mode,
+    blink::TransactionMode mode,
     IndexedDBDatabase* database,
     IndexedDBBackingStore::Transaction* backing_store_transaction)
     : id_(id),
       object_store_ids_(object_store_ids),
       mode_(mode),
       used_(false),
       state_(CREATED),
       commit_pending_(false),
       callbacks_(callbacks),
       database_(database),
@@ skipping 11 matching lines @@
 IndexedDBTransaction::~IndexedDBTransaction() {
   // It shouldn't be possible for this object to get deleted until it's either
   // complete or aborted.
   DCHECK_EQ(state_, FINISHED);
   DCHECK(preemptive_task_queue_.empty());
   DCHECK_EQ(pending_preemptive_events_, 0);
   DCHECK(task_queue_.empty());
   DCHECK(abort_task_stack_.empty());
 }
 
-void IndexedDBTransaction::ScheduleTask(IndexedDBDatabase::TaskType type,
-                                        Operation task) {
+void IndexedDBTransaction::ScheduleTask(blink::TaskType type, Operation task) {
   DCHECK_NE(state_, COMMITTING);
   if (state_ == FINISHED)
     return;
 
   timeout_timer_.Stop();
   used_ = true;
-  if (type == IndexedDBDatabase::NORMAL_TASK) {
+  if (type == blink::NormalTask) {
     task_queue_.push(task);
     ++diagnostics_.tasks_scheduled;
   } else {
     preemptive_task_queue_.push(task);
   }
   RunTasksIfStarted();
 }
 
 void IndexedDBTransaction::ScheduleAbortTask(Operation abort_task) {
   DCHECK_NE(FINISHED, state_);
@@ skipping 254 matching lines @@
 
   // The transaction may have been aborted while processing tasks.
   if (state_ == FINISHED)
     return;
 
   DCHECK(state_ == STARTED);
 
   // Otherwise, start a timer in case the front-end gets wedged and
   // never requests further activity. Read-only transactions don't
   // block other transactions, so don't time those out.
-  if (mode_ != indexed_db::TRANSACTION_READ_ONLY) {
+  if (mode_ != blink::TransactionReadOnly) {
     timeout_timer_.Start(
         FROM_HERE,
         base::TimeDelta::FromSeconds(kInactivityTimeoutPeriodSeconds),
         base::Bind(&IndexedDBTransaction::Timeout, this));
   }
 }
 
 void IndexedDBTransaction::Timeout() {
   Abort(IndexedDBDatabaseError(
       blink::WebIDBDatabaseExceptionTimeoutError,
       base::ASCIIToUTF16("Transaction timed out due to inactivity.")));
 }
 
 void IndexedDBTransaction::CloseOpenCursors() {
   for (std::set<IndexedDBCursor*>::iterator i = open_cursors_.begin();
        i != open_cursors_.end();
        ++i)
     (*i)->Close();
   open_cursors_.clear();
 }
 
 }  // namespace content