Rename es => exceptionState in other than bindings/

Source/core/inspector/InspectorIndexedDBAgent.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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 91 matching lines @@
     virtual void handleEvent(ExecutionContext*, Event* event) OVERRIDE
     {
         if (!m_requestCallback->isActive())
             return;
         if (event->type() != EventTypeNames::success) {
             m_requestCallback->sendFailure("Unexpected event type.");
             return;
         }
 
         IDBRequest* idbRequest = static_cast<IDBRequest*>(event->target());
-        TrackExceptionState es;
-        RefPtr<IDBAny> requestResult = idbRequest->result(es);
-        if (es.hadException()) {
+        TrackExceptionState exceptionState;
+        RefPtr<IDBAny> requestResult = idbRequest->result(exceptionState);
+        if (exceptionState.hadException()) {
             m_requestCallback->sendFailure("Could not get result in callback.");
             return;
         }
         if (requestResult->type() != IDBAny::DOMStringListType) {
             m_requestCallback->sendFailure("Unexpected result type.");
             return;
         }
 
         RefPtr<DOMStringList> databaseNamesList = requestResult->domStringList();
         RefPtr<TypeBuilder::Array<String> > databaseNames = TypeBuilder::Array<String>::create();
@@ skipping 39 matching lines @@
     }
 
     virtual void handleEvent(ExecutionContext*, Event* event) OVERRIDE
     {
         if (event->type() != EventTypeNames::success) {
             m_executableWithDatabase->requestCallback()->sendFailure("Unexpected event type.");
             return;
         }
 
         IDBOpenDBRequest* idbOpenDBRequest = static_cast<IDBOpenDBRequest*>(event->target());
-        TrackExceptionState es;
-        RefPtr<IDBAny> requestResult = idbOpenDBRequest->result(es);
-        if (es.hadException()) {
+        TrackExceptionState exceptionState;
+        RefPtr<IDBAny> requestResult = idbOpenDBRequest->result(exceptionState);
+        if (exceptionState.hadException()) {
             m_executableWithDatabase->requestCallback()->sendFailure("Could not get result in callback.");
             return;
         }
         if (requestResult->type() != IDBAny::IDBDatabaseType) {
             m_executableWithDatabase->requestCallback()->sendFailure("Unexpected result type.");
             return;
         }
 
         RefPtr<IDBDatabase> idbDatabase = requestResult->idbDatabase();
         m_executableWithDatabase->execute(idbDatabase);
         IDBPendingTransactionMonitor::deactivateNewTransactions();
         idbDatabase->close();
     }
 
 private:
     OpenDatabaseCallback(ExecutableWithDatabase* executableWithDatabase)
         : EventListener(EventListener::CPPEventListenerType)
         , m_executableWithDatabase(executableWithDatabase) { }
     RefPtr<ExecutableWithDatabase> m_executableWithDatabase;
 };
 
 void ExecutableWithDatabase::start(IDBFactory* idbFactory, SecurityOrigin*, const String& databaseName)
 {
     RefPtr<OpenDatabaseCallback> callback = OpenDatabaseCallback::create(this);
-    TrackExceptionState es;
-    RefPtr<IDBOpenDBRequest> idbOpenDBRequest = idbFactory->open(context(), databaseName, es);
-    if (es.hadException()) {
+    TrackExceptionState exceptionState;
+    RefPtr<IDBOpenDBRequest> idbOpenDBRequest = idbFactory->open(context(), databaseName, exceptionState);
+    if (exceptionState.hadException()) {
         requestCallback()->sendFailure("Could not open database.");
         return;
     }
     idbOpenDBRequest->addEventListener(EventTypeNames::success, callback, false);
 }
 
 static PassRefPtr<IDBTransaction> transactionForDatabase(ExecutionContext* executionContext, IDBDatabase* idbDatabase, const String& objectStoreName, const String& mode = IDBTransaction::modeReadOnly())
 {
-    TrackExceptionState es;
-    RefPtr<IDBTransaction> idbTransaction = idbDatabase->transaction(executionContext, objectStoreName, mode, es);
-    if (es.hadException())
+    TrackExceptionState exceptionState;
+    RefPtr<IDBTransaction> idbTransaction = idbDatabase->transaction(executionContext, objectStoreName, mode, exceptionState);
+    if (exceptionState.hadException())
         return 0;
     return idbTransaction;
 }
 
 static PassRefPtr<IDBObjectStore> objectStoreForTransaction(IDBTransaction* idbTransaction, const String& objectStoreName)
 {
-    TrackExceptionState es;
-    RefPtr<IDBObjectStore> idbObjectStore = idbTransaction->objectStore(objectStoreName, es);
-    if (es.hadException())
+    TrackExceptionState exceptionState;
+    RefPtr<IDBObjectStore> idbObjectStore = idbTransaction->objectStore(objectStoreName, exceptionState);
+    if (exceptionState.hadException())
         return 0;
     return idbObjectStore;
 }
 
 static PassRefPtr<IDBIndex> indexForObjectStore(IDBObjectStore* idbObjectStore, const String& indexName)
 {
-    TrackExceptionState es;
-    RefPtr<IDBIndex> idbIndex = idbObjectStore->index(indexName, es);
-    if (es.hadException())
+    TrackExceptionState exceptionState;
+    RefPtr<IDBIndex> idbIndex = idbObjectStore->index(indexName, exceptionState);
+    if (exceptionState.hadException())
         return 0;
     return idbIndex;
 }
 
 static PassRefPtr<KeyPath> keyPathFromIDBKeyPath(const IDBKeyPath& idbKeyPath)
 {
     RefPtr<KeyPath> keyPath;
     switch (idbKeyPath.type()) {
     case IDBKeyPath::NullType:
         keyPath = KeyPath::create().setType(KeyPath::Type::Null);
@@ skipping 165 matching lines @@
     }
 
     virtual void handleEvent(ExecutionContext* context, Event* event) OVERRIDE
     {
         if (event->type() != EventTypeNames::success) {
             m_requestCallback->sendFailure("Unexpected event type.");
             return;
         }
 
         IDBRequest* idbRequest = static_cast<IDBRequest*>(event->target());
-        TrackExceptionState es;
-        RefPtr<IDBAny> requestResult = idbRequest->result(es);
-        if (es.hadException()) {
+        TrackExceptionState exceptionState;
+        RefPtr<IDBAny> requestResult = idbRequest->result(exceptionState);
+        if (exceptionState.hadException()) {
             m_requestCallback->sendFailure("Could not get result in callback.");
             return;
         }
         if (requestResult->type() == IDBAny::ScriptValueType) {
             end(false);
             return;
         }
         if (requestResult->type() != IDBAny::IDBCursorWithValueType) {
             m_requestCallback->sendFailure("Unexpected result type.");
             return;
         }
 
         RefPtr<IDBCursorWithValue> idbCursor = requestResult->idbCursorWithValue();
 
         if (m_skipCount) {
-            TrackExceptionState es;
-            idbCursor->advance(m_skipCount, es);
-            if (es.hadException())
+            TrackExceptionState exceptionState;
+            idbCursor->advance(m_skipCount, exceptionState);
+            if (exceptionState.hadException())
                 m_requestCallback->sendFailure("Could not advance cursor.");
             m_skipCount = 0;
             return;
         }
 
         if (m_result->length() == m_pageSize) {
             end(true);
             return;
         }
 
         // Continue cursor before making injected script calls, otherwise transaction might be finished.
-        idbCursor->continueFunction(0, es);
-        if (es.hadException()) {
+        idbCursor->continueFunction(0, exceptionState);
+        if (exceptionState.hadException()) {
             m_requestCallback->sendFailure("Could not continue cursor.");
             return;
         }
 
         RefPtr<DataEntry> dataEntry = DataEntry::create()
             .setKey(m_injectedScript.wrapObject(idbCursor->key(context), String()))
             .setPrimaryKey(m_injectedScript.wrapObject(idbCursor->primaryKey(context), String()))
             .setValue(m_injectedScript.wrapObject(idbCursor->value(context), String()));
         m_result->addItem(dataEntry);
 
@@ skipping 154 matching lines @@
     IDBFactory* idbFactory = assertIDBFactory(errorString, document);
     if (!idbFactory)
         return;
 
     // FIXME: This should probably use ScriptState/ScriptScope instead of V8 API
     v8::HandleScope handleScope(toIsolate(frame));
     v8::Handle<v8::Context> context = document->frame()->script().mainWorldContext();
     ASSERT(!context.IsEmpty());
     v8::Context::Scope contextScope(context);
 
-    TrackExceptionState es;
-    RefPtr<IDBRequest> idbRequest = idbFactory->getDatabaseNames(document, es);
-    if (es.hadException()) {
+    TrackExceptionState exceptionState;
+    RefPtr<IDBRequest> idbRequest = idbFactory->getDatabaseNames(document, exceptionState);
+    if (exceptionState.hadException()) {
         requestCallback->sendFailure("Could not obtain database names.");
         return;
     }
     idbRequest->addEventListener(EventTypeNames::success, GetDatabaseNamesCallback::create(requestCallback, document->securityOrigin()->toRawString()), false);
 }
 
 void InspectorIndexedDBAgent::requestDatabase(ErrorString* errorString, const String& securityOrigin, const String& databaseName, PassRefPtr<RequestDatabaseCallback> requestCallback)
 {
     Frame* frame = m_pageAgent->findFrameWithSecurityOrigin(securityOrigin);
     Document* document = assertDocument(errorString, frame);
@@ skipping 101 matching lines @@
         if (!idbTransaction) {
             m_requestCallback->sendFailure("Could not get transaction");
             return;
         }
         RefPtr<IDBObjectStore> idbObjectStore = objectStoreForTransaction(idbTransaction.get(), m_objectStoreName);
         if (!idbObjectStore) {
             m_requestCallback->sendFailure("Could not get object store");
             return;
         }
 
-        TrackExceptionState es;
-        RefPtr<IDBRequest> idbRequest = idbObjectStore->clear(context(), es);
-        ASSERT(!es.hadException());
-        if (es.hadException()) {
-            ExceptionCode ec = es.code();
+        TrackExceptionState exceptionState;
+        RefPtr<IDBRequest> idbRequest = idbObjectStore->clear(context(), exceptionState);
+        ASSERT(!exceptionState.hadException());
+        if (exceptionState.hadException()) {
+            ExceptionCode ec = exceptionState.code();
             m_requestCallback->sendFailure(String::format("Could not clear object store '%s': %d", m_objectStoreName.utf8().data(), ec));
             return;
         }
         idbTransaction->addEventListener(EventTypeNames::complete, ClearObjectStoreListener::create(m_requestCallback), false);
     }
 
     virtual RequestCallback* requestCallback() { return m_requestCallback.get(); }
 private:
     const String m_objectStoreName;
     RefPtr<ClearObjectStoreCallback> m_requestCallback;
@@ skipping 13 matching lines @@
     v8::HandleScope handleScope(toIsolate(frame));
     v8::Handle<v8::Context> context = document->frame()->script().mainWorldContext();
     ASSERT(!context.IsEmpty());
     v8::Context::Scope contextScope(context);
 
     RefPtr<ClearObjectStore> clearObjectStore = ClearObjectStore::create(document, objectStoreName, requestCallback);
     clearObjectStore->start(idbFactory, document->securityOrigin(), databaseName);
 }
 
 } // namespace WebCore