DevTools: migrate remote debugging protocol generators to jinja2.

third_party/WebKit/Source/modules/filesystem/InspectorFileSystemAgent.cpp

Index: third_party/WebKit/Source/modules/filesystem/InspectorFileSystemAgent.cpp
diff --git a/third_party/WebKit/Source/modules/filesystem/InspectorFileSystemAgent.cpp b/third_party/WebKit/Source/modules/filesystem/InspectorFileSystemAgent.cpp
index 2ebeb568317fe14fb33dcf9223b080508d8f821b..39fc090dde4776b526f250f0156277b67e78a397 100644
--- a/third_party/WebKit/Source/modules/filesystem/InspectorFileSystemAgent.cpp
+++ b/third_party/WebKit/Source/modules/filesystem/InspectorFileSystemAgent.cpp
@@ -65,8 +65,6 @@
 #include "wtf/text/Base64.h"
 #include "wtf/text/TextEncoding.h"
 
-using blink::protocol::TypeBuilder::Array;
-
 typedef blink::protocol::Dispatcher::FileSystemCommandHandler::RequestFileSystemRootCallback RequestFileSystemRootCallback;
 typedef blink::protocol::Dispatcher::FileSystemCommandHandler::RequestDirectoryContentCallback RequestDirectoryContentCallback;
 typedef blink::protocol::Dispatcher::FileSystemCommandHandler::RequestMetadataCallback RequestMetadataCallback;
@@ -75,6 +73,9 @@ typedef blink::protocol::Dispatcher::FileSystemCommandHandler::DeleteEntryCallba
 
 namespace blink {
 
+using namespace protocol;
+using TypeBuilder::Array;
+
 namespace FileSystemAgentState {
 static const char fileSystemAgentEnabled[] = "fileSystemAgentEnabled";
 }
@@ -144,7 +145,7 @@ private:
 
     bool didGetEntry(Entry*);
 
-    void reportResult(FileError::ErrorCode errorCode, PassRefPtr<protocol::TypeBuilder::FileSystem::Entry> entry = nullptr)
+    void reportResult(FileError::ErrorCode errorCode, PassOwnPtr<protocol::TypeBuilder::FileSystem::Entry> entry = nullptr)
     {
         m_requestCallback->sendSuccess(static_cast<int>(errorCode), entry);
     }
@@ -182,11 +183,11 @@ void FileSystemRootRequest::start(ExecutionContext* executionContext)
 
 bool FileSystemRootRequest::didGetEntry(Entry* entry)
 {
-    RefPtr<protocol::TypeBuilder::FileSystem::Entry> result = protocol::TypeBuilder::FileSystem::Entry::create()
+    OwnPtr<protocol::TypeBuilder::FileSystem::Entry> result = protocol::TypeBuilder::FileSystem::Entry::create()
         .setUrl(entry->toURL())
         .setName("/")
-        .setIsDirectory(true);
-    reportResult(static_cast<FileError::ErrorCode>(0), result);
+        .setIsDirectory(true).build();
+    reportResult(static_cast<FileError::ErrorCode>(0), result.release());
     return true;
 }
 
@@ -219,7 +220,7 @@ private:
     bool didGetEntry(Entry*);
     bool didReadDirectoryEntries(const EntryHeapVector&);
 
-    void reportResult(FileError::ErrorCode errorCode, PassRefPtr<Array<protocol::TypeBuilder::FileSystem::Entry>> entries = nullptr)
+    void reportResult(FileError::ErrorCode errorCode, PassOwnPtr<Array<protocol::TypeBuilder::FileSystem::Entry>> entries = nullptr)
     {
         m_requestCallback->sendSuccess(static_cast<int>(errorCode), entries);
     }
@@ -232,7 +233,7 @@ private:
 
     RefPtr<RequestDirectoryContentCallback> m_requestCallback;
     KURL m_url;
-    RefPtr<Array<protocol::TypeBuilder::FileSystem::Entry>> m_entries;
+    OwnPtr<Array<protocol::TypeBuilder::FileSystem::Entry>> m_entries;
     PersistentWillBeMember<DirectoryReader> m_directoryReader;
 };
 
@@ -276,35 +277,33 @@ void DirectoryContentRequest::readDirectoryEntries()
 bool DirectoryContentRequest::didReadDirectoryEntries(const EntryHeapVector& entries)
 {
     if (entries.isEmpty()) {
-        reportResult(static_cast<FileError::ErrorCode>(0), m_entries);
+        reportResult(static_cast<FileError::ErrorCode>(0), m_entries.release());
         return true;
     }
 
     for (size_t i = 0; i < entries.size(); ++i) {
         Entry* entry = entries[i];
-        RefPtr<protocol::TypeBuilder::FileSystem::Entry> entryForFrontend = protocol::TypeBuilder::FileSystem::Entry::create()
+        OwnPtr<protocol::TypeBuilder::FileSystem::Entry> entryForFrontend = protocol::TypeBuilder::FileSystem::Entry::create()
             .setUrl(entry->toURL())
             .setName(entry->name())
-            .setIsDirectory(entry->isDirectory());
-
-        using protocol::TypeBuilder::Page::ResourceType;
+            .setIsDirectory(entry->isDirectory()).build();
         if (!entry->isDirectory()) {
             String mimeType = MIMETypeRegistry::getMIMETypeForPath(entry->name());
-            ResourceType::Enum resourceType;
+            String resourceType;
             if (MIMETypeRegistry::isSupportedImageMIMEType(mimeType)) {
-                resourceType = ResourceType::Image;
+                resourceType = TypeBuilder::Page::ResourceTypeEnum::Image;
                 entryForFrontend->setIsTextFile(false);
             } else if (HTMLMediaElement::supportsType(ContentType(mimeType)) != WebMimeRegistry::IsNotSupported) {
-                resourceType = ResourceType::Media;
+                resourceType = TypeBuilder::Page::ResourceTypeEnum::Media;
                 entryForFrontend->setIsTextFile(false);
             } else if (MIMETypeRegistry::isSupportedJavaScriptMIMEType(mimeType)) {
-                resourceType = ResourceType::Script;
+                resourceType = TypeBuilder::Page::ResourceTypeEnum::Script;
                 entryForFrontend->setIsTextFile(true);
             } else if (MIMETypeRegistry::isSupportedNonImageMIMEType(mimeType)) {
-                resourceType = ResourceType::Document;
+                resourceType = TypeBuilder::Page::ResourceTypeEnum::Document;
                 entryForFrontend->setIsTextFile(true);
             } else {
-                resourceType = ResourceType::Other;
+                resourceType = TypeBuilder::Page::ResourceTypeEnum::Other;
                 entryForFrontend->setIsTextFile(DOMImplementation::isXMLMIMEType(mimeType) || DOMImplementation::isTextMIMEType(mimeType));
             }
 
@@ -312,7 +311,7 @@ bool DirectoryContentRequest::didReadDirectoryEntries(const EntryHeapVector& ent
             entryForFrontend->setResourceType(resourceType);
         }
 
-        m_entries->addItem(entryForFrontend);
+        m_entries->addItem(entryForFrontend.release());
     }
     readDirectoryEntries();
     return true;
@@ -346,7 +345,7 @@ private:
     bool didGetEntry(Entry*);
     bool didGetMetadata(Metadata*);
 
-    void reportResult(FileError::ErrorCode errorCode, PassRefPtr<protocol::TypeBuilder::FileSystem::Metadata> metadata = nullptr)
+    void reportResult(FileError::ErrorCode errorCode, PassOwnPtr<protocol::TypeBuilder::FileSystem::Metadata> metadata = nullptr)
     {
         m_requestCallback->sendSuccess(static_cast<int>(errorCode), metadata);
     }
@@ -387,10 +386,10 @@ bool MetadataRequest::didGetEntry(Entry* entry)
 bool MetadataRequest::didGetMetadata(Metadata* metadata)
 {
     using protocol::TypeBuilder::FileSystem::Metadata;
-    RefPtr<Metadata> result = Metadata::create()
+    OwnPtr<Metadata> result = Metadata::create()
         .setModificationTime(metadata->modificationTime())
-        .setSize(metadata->size());
-    reportResult(static_cast<FileError::ErrorCode>(0), result);
+        .setSize(metadata->size()).build();
+    reportResult(static_cast<FileError::ErrorCode>(0), result.release());
     return true;
 }
 
@@ -440,7 +439,7 @@ private:
 
     void reportResult(FileError::ErrorCode errorCode, const String* result = 0, const String* charset = 0)
     {
-        m_requestCallback->sendSuccess(static_cast<int>(errorCode), result, charset);
+        m_requestCallback->sendSuccess(static_cast<int>(errorCode), TypeBuilder::optional(result), TypeBuilder::optional(charset));
     }
 
     FileContentRequest(PassRefPtr<RequestFileContentCallback> requestCallback, const String& url, bool readAsText, long long start, long long end, const String& charset)
@@ -661,64 +660,84 @@ void InspectorFileSystemAgent::disable(ErrorString*)
 
 void InspectorFileSystemAgent::requestFileSystemRoot(ErrorString* error, const String& origin, const String& type, PassRefPtr<RequestFileSystemRootCallback> requestCallback)
 {
-    if (!assertEnabled(error))
+    if (!assertEnabled(error)) {
+        requestCallback->sendFailure(*error);
         return;
+    }
 
     ExecutionContext* executionContext = assertExecutionContextForOrigin(error, SecurityOrigin::createFromString(origin).get());
-    if (!executionContext)
+    if (!executionContext) {
+        requestCallback->sendFailure(*error);
         return;
+    }
 
     FileSystemRootRequest::create(requestCallback, type)->start(executionContext);
 }
 
 void InspectorFileSystemAgent::requestDirectoryContent(ErrorString* error, const String& url, PassRefPtr<RequestDirectoryContentCallback> requestCallback)
 {
-    if (!assertEnabled(error))
+    if (!assertEnabled(error)) {
+        requestCallback->sendFailure(*error);
         return;
+    }
 
     ExecutionContext* executionContext = assertExecutionContextForOrigin(error, SecurityOrigin::createFromString(url).get());
-    if (!executionContext)
+    if (!executionContext) {
+        requestCallback->sendFailure(*error);
         return;
+    }
 
     DirectoryContentRequest::create(requestCallback, url)->start(executionContext);
 }
 
 void InspectorFileSystemAgent::requestMetadata(ErrorString* error, const String& url, PassRefPtr<RequestMetadataCallback> requestCallback)
 {
-    if (!assertEnabled(error))
+    if (!assertEnabled(error)) {
+        requestCallback->sendFailure(*error);
         return;
+    }
 
     ExecutionContext* executionContext = assertExecutionContextForOrigin(error, SecurityOrigin::createFromString(url).get());
-    if (!executionContext)
+    if (!executionContext) {
+        requestCallback->sendFailure(*error);
         return;
+    }
 
     MetadataRequest::create(requestCallback, url)->start(executionContext);
 }
 
-void InspectorFileSystemAgent::requestFileContent(ErrorString* error, const String& url, bool readAsText, const int* start, const int* end, const String* charset, PassRefPtr<RequestFileContentCallback> requestCallback)
+void InspectorFileSystemAgent::requestFileContent(ErrorString* error, const String& url, bool readAsText, const OptionalValue<int>& start, const OptionalValue<int>& end, const OptionalValue<String>& charset, PassRefPtr<RequestFileContentCallback> requestCallback)
 {
-    if (!assertEnabled(error))
+    if (!assertEnabled(error)) {
+        requestCallback->sendFailure(*error);
         return;
+    }
 
     ExecutionContext* executionContext = assertExecutionContextForOrigin(error, SecurityOrigin::createFromString(url).get());
-    if (!executionContext)
+    if (!executionContext) {
+        requestCallback->sendFailure(*error);
         return;
+    }
 
-    long long startPosition = start ? *start : 0;
-    long long endPosition = end ? *end : std::numeric_limits<long long>::max();
-    FileContentRequest::create(requestCallback, url, readAsText, startPosition, endPosition, charset ? *charset : "")->start(executionContext);
+    int startPosition = start.get(0);
+    int endPosition = end.get(std::numeric_limits<int>::max());
+    FileContentRequest::create(requestCallback, url, readAsText, startPosition, endPosition, charset.get(""))->start(executionContext);
 }
 
 void InspectorFileSystemAgent::deleteEntry(ErrorString* error, const String& urlString, PassRefPtr<DeleteEntryCallback> requestCallback)
 {
-    if (!assertEnabled(error))
+    if (!assertEnabled(error)) {
+        requestCallback->sendFailure(*error);
         return;
+    }
 
     KURL url(ParsedURLString, urlString);
 
     ExecutionContext* executionContext = assertExecutionContextForOrigin(error, SecurityOrigin::create(url).get());
-    if (!executionContext)
+    if (!executionContext) {
+        requestCallback->sendFailure(*error);
         return;
+    }
 
     DeleteEntryRequest::create(requestCallback, url)->start(executionContext);
 }