DevTools: migrate remote debugging protocol generators to jinja2.

third_party/WebKit/Source/modules/indexeddb/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 44 matching lines @@
 #include "modules/indexeddb/IDBOpenDBRequest.h"
 #include "modules/indexeddb/IDBRequest.h"
 #include "modules/indexeddb/IDBTransaction.h"
 #include "platform/JSONValues.h"
 #include "platform/JSONValuesForV8.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "public/platform/modules/indexeddb/WebIDBCursor.h"
 #include "public/platform/modules/indexeddb/WebIDBTypes.h"
 #include "wtf/Vector.h"
 
-using blink::protocol::TypeBuilder::Array;
-using blink::protocol::TypeBuilder::IndexedDB::DatabaseWithObjectStores;
-using blink::protocol::TypeBuilder::IndexedDB::DataEntry;
-using blink::protocol::TypeBuilder::IndexedDB::Key;
-using blink::protocol::TypeBuilder::IndexedDB::KeyPath;
-using blink::protocol::TypeBuilder::IndexedDB::KeyRange;
-using blink::protocol::TypeBuilder::IndexedDB::ObjectStore;
-using blink::protocol::TypeBuilder::IndexedDB::ObjectStoreIndex;
+using blink::protocol::Array;
+using blink::protocol::IndexedDB::DatabaseWithObjectStores;
+using blink::protocol::IndexedDB::DataEntry;
+using blink::protocol::IndexedDB::Key;
+using blink::protocol::IndexedDB::KeyPath;
+using blink::protocol::IndexedDB::KeyRange;
+using blink::protocol::IndexedDB::ObjectStore;
+using blink::protocol::IndexedDB::ObjectStoreIndex;
 
 typedef blink::protocol::Dispatcher::IndexedDBCommandHandler::RequestDatabaseNamesCallback RequestDatabaseNamesCallback;
 typedef blink::protocol::Dispatcher::IndexedDBCommandHandler::RequestDatabaseCallback RequestDatabaseCallback;
 typedef blink::protocol::Dispatcher::IndexedDBCommandHandler::RequestDataCallback RequestDataCallback;
 typedef blink::protocol::Dispatcher::CallbackBase RequestCallback;
 typedef blink::protocol::Dispatcher::IndexedDBCommandHandler::ClearObjectStoreCallback ClearObjectStoreCallback;
 
 namespace blink {
 
 namespace IndexedDBAgentState {
@@ skipping 27 matching lines @@
         }
 
         IDBRequest* idbRequest = static_cast<IDBRequest*>(event->target());
         IDBAny* requestResult = idbRequest->resultAsAny();
         if (requestResult->type() != IDBAny::DOMStringListType) {
             m_requestCallback->sendFailure("Unexpected result type.");
             return;
         }
 
         RefPtrWillBeRawPtr<DOMStringList> databaseNamesList = requestResult->domStringList();
-        RefPtr<protocol::TypeBuilder::Array<String>> databaseNames = protocol::TypeBuilder::Array<String>::create();
+        OwnPtr<protocol::Array<String>> databaseNames = protocol::Array<String>::create();
         for (size_t i = 0; i < databaseNamesList->length(); ++i)
             databaseNames->addItem(databaseNamesList->anonymousIndexedGetter(i));
         m_requestCallback->sendSuccess(databaseNames.release());
     }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         EventListener::trace(visitor);
     }
 
@@ skipping 134 matching lines @@
 
 static IDBIndex* indexForObjectStore(IDBObjectStore* idbObjectStore, const String& indexName)
 {
     TrackExceptionState exceptionState;
     IDBIndex* idbIndex = idbObjectStore->index(indexName, exceptionState);
     if (exceptionState.hadException())
         return nullptr;
     return idbIndex;
 }
 
-static PassRefPtr<KeyPath> keyPathFromIDBKeyPath(const IDBKeyPath& idbKeyPath)
+static PassOwnPtr<KeyPath> keyPathFromIDBKeyPath(const IDBKeyPath& idbKeyPath)
 {
-    RefPtr<KeyPath> keyPath;
+    OwnPtr<KeyPath> keyPath;
     switch (idbKeyPath.type()) {
     case IDBKeyPath::NullType:
-        keyPath = KeyPath::create().setType(KeyPath::Type::Null);
+        keyPath = KeyPath::create().setType(KeyPath::TypeEnum::Null).build();
         break;
     case IDBKeyPath::StringType:
-        keyPath = KeyPath::create().setType(KeyPath::Type::String);
-        keyPath->setString(idbKeyPath.string());
+        keyPath = KeyPath::create().setType(KeyPath::TypeEnum::String).setString(idbKeyPath.string()).build();
         break;
     case IDBKeyPath::ArrayType: {
-        keyPath = KeyPath::create().setType(KeyPath::Type::Array);
-        RefPtr<protocol::TypeBuilder::Array<String>> array = protocol::TypeBuilder::Array<String>::create();
+        keyPath = KeyPath::create().setType(KeyPath::TypeEnum::Array).build();
+        OwnPtr<protocol::Array<String>> array = protocol::Array<String>::create();
         const Vector<String>& stringArray = idbKeyPath.array();
         for (size_t i = 0; i < stringArray.size(); ++i)
             array->addItem(stringArray[i]);
-        keyPath->setArray(array);
+        keyPath->setArray(array.release());
         break;
     }
     default:
         ASSERT_NOT_REACHED();
     }
 
     return keyPath.release();
 }
 
 class DatabaseLoader final : public ExecutableWithDatabase {
 public:
     static PassRefPtr<DatabaseLoader> create(ScriptState* scriptState, PassRefPtr<RequestDatabaseCallback> requestCallback)
     {
         return adoptRef(new DatabaseLoader(scriptState, requestCallback));
     }
 
     ~DatabaseLoader() override { }
 
     void execute(IDBDatabase* idbDatabase) override
     {
         if (!requestCallback()->isActive())
             return;
 
         const IDBDatabaseMetadata databaseMetadata = idbDatabase->metadata();
 
-        RefPtr<protocol::TypeBuilder::Array<protocol::TypeBuilder::IndexedDB::ObjectStore>> objectStores = protocol::TypeBuilder::Array<protocol::TypeBuilder::IndexedDB::ObjectStore>::create();
+        OwnPtr<protocol::Array<protocol::IndexedDB::ObjectStore>> objectStores = protocol::Array<protocol::IndexedDB::ObjectStore>::create();
 
         for (const auto& storeMapEntry : databaseMetadata.objectStores) {
             const IDBObjectStoreMetadata& objectStoreMetadata = storeMapEntry.value;
 
-            RefPtr<protocol::TypeBuilder::Array<protocol::TypeBuilder::IndexedDB::ObjectStoreIndex>> indexes = protocol::TypeBuilder::Array<protocol::TypeBuilder::IndexedDB::ObjectStoreIndex>::create();
+            OwnPtr<protocol::Array<protocol::IndexedDB::ObjectStoreIndex>> indexes = protocol::Array<protocol::IndexedDB::ObjectStoreIndex>::create();
 
             for (const auto& metadataMapEntry : objectStoreMetadata.indexes) {
                 const IDBIndexMetadata& indexMetadata = metadataMapEntry.value;
 
-                RefPtr<ObjectStoreIndex> objectStoreIndex = ObjectStoreIndex::create()
+                OwnPtr<ObjectStoreIndex> objectStoreIndex = ObjectStoreIndex::create()
                     .setName(indexMetadata.name)
                     .setKeyPath(keyPathFromIDBKeyPath(indexMetadata.keyPath))
                     .setUnique(indexMetadata.unique)
-                    .setMultiEntry(indexMetadata.multiEntry);
-                indexes->addItem(objectStoreIndex);
+                    .setMultiEntry(indexMetadata.multiEntry).build();
+                indexes->addItem(objectStoreIndex.release());
             }
 
-            RefPtr<ObjectStore> objectStore = ObjectStore::create()
+            OwnPtr<ObjectStore> objectStore = ObjectStore::create()
                 .setName(objectStoreMetadata.name)
                 .setKeyPath(keyPathFromIDBKeyPath(objectStoreMetadata.keyPath))
                 .setAutoIncrement(objectStoreMetadata.autoIncrement)
-                .setIndexes(indexes);
-            objectStores->addItem(objectStore);
+                .setIndexes(indexes.release()).build();
+            objectStores->addItem(objectStore.release());
         }
-        RefPtr<DatabaseWithObjectStores> result = DatabaseWithObjectStores::create()
+        OwnPtr<DatabaseWithObjectStores> result = DatabaseWithObjectStores::create()
             .setName(databaseMetadata.name)
             .setIntVersion(databaseMetadata.intVersion)
-            .setObjectStores(objectStores);
+            .setObjectStores(objectStores.release()).build();
 
-        m_requestCallback->sendSuccess(result);
+        m_requestCallback->sendSuccess(result.release());
     }
 
     RequestCallback* requestCallback() override { return m_requestCallback.get(); }
 private:
     DatabaseLoader(ScriptState* scriptState, PassRefPtr<RequestDatabaseCallback> requestCallback)
         : ExecutableWithDatabase(scriptState)
         , m_requestCallback(requestCallback) { }
     RefPtr<RequestDatabaseCallback> m_requestCallback;
 };
 
-static IDBKey* idbKeyFromInspectorObject(JSONObject* key)
+static IDBKey* idbKeyFromInspectorObject(PassOwnPtr<protocol::IndexedDB::Key> key)
 {
     IDBKey* idbKey;
 
-    String type;
-    if (!key->getString("type", &type))
+    if (!key || !key->hasType())
         return nullptr;
+    String type = key->getType();
 
     DEFINE_STATIC_LOCAL(String, s_number, ("number"));
     DEFINE_STATIC_LOCAL(String, s_string, ("string"));
     DEFINE_STATIC_LOCAL(String, s_date, ("date"));
     DEFINE_STATIC_LOCAL(String, s_array, ("array"));
 
     if (type == s_number) {
-        double number;
-        if (!key->getNumber("number", &number))
+        if (!key->hasNumber())
             return nullptr;
-        idbKey = IDBKey::createNumber(number);
+        idbKey = IDBKey::createNumber(key->getNumber(0));
     } else if (type == s_string) {
-        String string;
-        if (!key->getString("string", &string))
+        if (!key->hasString())
             return nullptr;
-        idbKey = IDBKey::createString(string);
+        idbKey = IDBKey::createString(key->getString(String()));
     } else if (type == s_date) {
-        double date;
-        if (!key->getNumber("date", &date))
+        if (!key->hasDate())
             return nullptr;
-        idbKey = IDBKey::createDate(date);
+        idbKey = IDBKey::createDate(key->getDate(0));
     } else if (type == s_array) {
         IDBKey::KeyArray keyArray;
-        RefPtr<JSONArray> array = key->getArray("array");
-        for (size_t i = 0; i < array->length(); ++i) {
-            RefPtr<JSONValue> value = array->get(i);
-            RefPtr<JSONObject> object;
-            if (!value->asObject(&object))
-                return nullptr;
-            keyArray.append(idbKeyFromInspectorObject(object.get()));
-        }
+        auto array = key->getArray(nullptr);
+        for (size_t i = 0; array && i < array->length(); ++i)
+            keyArray.append(idbKeyFromInspectorObject(array->get(i)));
         idbKey = IDBKey::createArray(keyArray);
     } else {
         return nullptr;
     }
 
     return idbKey;
 }
 
-static IDBKeyRange* idbKeyRangeFromKeyRange(JSONObject* keyRange)
+static IDBKeyRange* idbKeyRangeFromKeyRange(PassOwnPtr<protocol::IndexedDB::KeyRange> keyRange)
 {
-    RefPtr<JSONObject> lower = keyRange->getObject("lower");
-    IDBKey* idbLower = lower ? idbKeyFromInspectorObject(lower.get()) : nullptr;
-    if (lower && !idbLower)
+    IDBKey* idbLower = idbKeyFromInspectorObject(keyRange->getLower(nullptr));
+    if (keyRange->hasLower() && !idbLower)
         return nullptr;
 
-    RefPtr<JSONObject> upper = keyRange->getObject("upper");
-    IDBKey* idbUpper = upper ? idbKeyFromInspectorObject(upper.get()) : nullptr;
-    if (upper && !idbUpper)
+    IDBKey* idbUpper = idbKeyFromInspectorObject(keyRange->getUpper(nullptr));
+    if (keyRange->hasUpper() && !idbUpper)
         return nullptr;
 
-    bool lowerOpen;
-    if (!keyRange->getBoolean("lowerOpen", &lowerOpen))
+    if (!keyRange->hasLowerOpen())
         return nullptr;
-    IDBKeyRange::LowerBoundType lowerBoundType = lowerOpen ? IDBKeyRange::LowerBoundOpen : IDBKeyRange::LowerBoundClosed;
+    IDBKeyRange::LowerBoundType lowerBoundType = keyRange->getLowerOpen() ? IDBKeyRange::LowerBoundOpen : IDBKeyRange::LowerBoundClosed;
 
-    bool upperOpen;
-    if (!keyRange->getBoolean("upperOpen", &upperOpen))
+    if (!keyRange->hasUpperOpen())
         return nullptr;
-    IDBKeyRange::UpperBoundType upperBoundType = upperOpen ? IDBKeyRange::UpperBoundOpen : IDBKeyRange::UpperBoundClosed;
+    IDBKeyRange::UpperBoundType upperBoundType = keyRange->getUpperOpen() ? IDBKeyRange::UpperBoundOpen : IDBKeyRange::UpperBoundClosed;
 
     return IDBKeyRange::create(idbLower, idbUpper, lowerBoundType, upperBoundType);
 }
 
 class DataLoader;
 
 class OpenCursorCallback final : public EventListener {
 public:
     static PassRefPtrWillBeRawPtr<OpenCursorCallback> create(ScriptState* scriptState, PassRefPtr<RequestDataCallback> requestCallback, int skipCount, unsigned pageSize)
     {
@@ skipping 56 matching lines @@
         // object is inspected.
         const String errorMessage("\"Inspection error. Maximum depth reached?\"");
         ScriptState* scriptState = m_scriptState.get();
         ScriptState::Scope scope(scriptState);
         RefPtr<JSONValue> keyJsonValue = toJSONValue(scriptState->context(), idbCursor->key(scriptState).v8Value());
         RefPtr<JSONValue> primaryKeyJsonValue = toJSONValue(scriptState->context(), idbCursor->primaryKey(scriptState).v8Value());
         RefPtr<JSONValue> valueJsonValue = toJSONValue(scriptState->context(), idbCursor->value(scriptState).v8Value());
         String key = keyJsonValue ? keyJsonValue->toJSONString() : errorMessage;
         String value = valueJsonValue ? valueJsonValue->toJSONString() : errorMessage;
         String primaryKey = primaryKeyJsonValue ? primaryKeyJsonValue->toJSONString() : errorMessage;
-        RefPtr<DataEntry> dataEntry = DataEntry::create()
+        OwnPtr<DataEntry> dataEntry = DataEntry::create()
             .setKey(key)
             .setPrimaryKey(primaryKey)
-            .setValue(value);
-        m_result->addItem(dataEntry);
+            .setValue(value).build();
+        m_result->addItem(dataEntry.release());
     }
 
     void end(bool hasMore)
     {
         if (!m_requestCallback->isActive())
             return;
         m_requestCallback->sendSuccess(m_result.release(), hasMore);
     }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         EventListener::trace(visitor);
     }
 
 private:
     OpenCursorCallback(ScriptState* scriptState, PassRefPtr<RequestDataCallback> requestCallback, int skipCount, unsigned pageSize)
         : EventListener(EventListener::CPPEventListenerType)
         , m_scriptState(scriptState)
         , m_requestCallback(requestCallback)
         , m_skipCount(skipCount)
         , m_pageSize(pageSize)
     {
         m_result = Array<DataEntry>::create();
     }
 
     RefPtr<ScriptState> m_scriptState;
     RefPtr<RequestDataCallback> m_requestCallback;
     int m_skipCount;
     unsigned m_pageSize;
-    RefPtr<Array<DataEntry>> m_result;
+    OwnPtr<Array<DataEntry>> m_result;
 };
 
 class DataLoader final : public ExecutableWithDatabase {
 public:
     static PassRefPtr<DataLoader> create(ScriptState* scriptState, PassRefPtr<RequestDataCallback> requestCallback, const String& objectStoreName, const String& indexName, IDBKeyRange* idbKeyRange, int skipCount, unsigned pageSize)
     {
         return adoptRef(new DataLoader(scriptState, requestCallback, objectStoreName, indexName, idbKeyRange, skipCount, pageSize));
     }
 
     ~DataLoader() override { }
@@ skipping 145 matching lines @@
         return;
 
     ScriptState* scriptState = ScriptState::forMainWorld(frame);
     if (!scriptState)
         return;
     ScriptState::Scope scope(scriptState);
     RefPtr<DatabaseLoader> databaseLoader = DatabaseLoader::create(scriptState, requestCallback);
     databaseLoader->start(idbFactory, document->securityOrigin(), databaseName);
 }
 
-void InspectorIndexedDBAgent::requestData(ErrorString* errorString, const String& securityOrigin, const String& databaseName, const String& objectStoreName, const String& indexName, int skipCount, int pageSize, const RefPtr<JSONObject>* keyRange, const PassRefPtr<RequestDataCallback> requestCallback)
+void InspectorIndexedDBAgent::requestData(ErrorString* errorString, const String& securityOrigin, const String& databaseName, const String& objectStoreName, const String& indexName, int skipCount, int pageSize, PassOwnPtr<protocol::IndexedDB::KeyRange> keyRange, const PassRefPtr<RequestDataCallback> requestCallback)
 {
     LocalFrame* frame = m_inspectedFrames->frameWithSecurityOrigin(securityOrigin);
     Document* document = assertDocument(errorString, frame);
     if (!document)
         return;
     IDBFactory* idbFactory = assertIDBFactory(errorString, document);
     if (!idbFactory)
         return;
 
-    IDBKeyRange* idbKeyRange = keyRange ? idbKeyRangeFromKeyRange(keyRange->get()) : nullptr;
+    IDBKeyRange* idbKeyRange = keyRange ? idbKeyRangeFromKeyRange(keyRange) : nullptr;
     if (keyRange && !idbKeyRange) {
         *errorString = "Can not parse key range.";
         return;
     }
 
     ScriptState* scriptState = ScriptState::forMainWorld(frame);
     if (!scriptState)
         return;
     ScriptState::Scope scope(scriptState);
     RefPtr<DataLoader> dataLoader = DataLoader::create(scriptState, requestCallback, objectStoreName, indexName, idbKeyRange, skipCount, pageSize);
@@ skipping 107 matching lines @@
     clearObjectStore->start(idbFactory, document->securityOrigin(), databaseName);
 }
 
 DEFINE_TRACE(InspectorIndexedDBAgent)
 {
     visitor->trace(m_inspectedFrames);
     InspectorBaseAgent::trace(visitor);
 }
 
 } // namespace blink