DevTools: migrate remote debugging protocol generators to jinja2.

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

 /*
  * Copyright (C) 2011, 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 47 matching lines @@
 #include "modules/filesystem/Metadata.h"
 #include "modules/filesystem/MetadataCallback.h"
 #include "platform/ContentType.h"
 #include "platform/MIMETypeRegistry.h"
 #include "platform/heap/Handle.h"
 #include "platform/weborigin/KURL.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #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;
 typedef blink::protocol::Dispatcher::FileSystemCommandHandler::RequestFileContentCallback RequestFileContentCallback;
 typedef blink::protocol::Dispatcher::FileSystemCommandHandler::DeleteEntryCallback DeleteEntryCallback;
 
 namespace blink {
 
+using namespace protocol;
+using TypeBuilder::Array;
+
 namespace FileSystemAgentState {
 static const char fileSystemAgentEnabled[] = "fileSystemAgentEnabled";
 }
 
 namespace {
 
 template<typename BaseCallback, typename Handler, typename Argument>
 class GC_PLUGIN_IGNORE("crbug.com/513077") CallbackDispatcher final : public BaseCallback {
 public:
     typedef bool (Handler::*HandlingMethod)(Argument);
@@ skipping 49 matching lines @@
 
 private:
     bool didHitError(FileError* error)
     {
         reportResult(error->code());
         return true;
     }
 
     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);
     }
 
     FileSystemRootRequest(PassRefPtr<RequestFileSystemRootCallback> requestCallback, const String& type)
         : m_requestCallback(requestCallback)
         , m_type(type) { }
 
     RefPtr<RequestFileSystemRootCallback> m_requestCallback;
     String m_type;
@@ skipping 17 matching lines @@
         return;
     }
 
     EntryCallback* successCallback = CallbackDispatcherFactory<EntryCallback>::create(this, &FileSystemRootRequest::didGetEntry);
     OwnPtr<AsyncFileSystemCallbacks> fileSystemCallbacks = ResolveURICallbacks::create(successCallback, errorCallback, executionContext);
     LocalFileSystem::from(*executionContext)->resolveURL(executionContext, rootURL, fileSystemCallbacks.release());
 }
 
 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;
 }
 
 class DirectoryContentRequest final : public RefCountedWillBeGarbageCollectedFinalized<DirectoryContentRequest> {
     WTF_MAKE_NONCOPYABLE(DirectoryContentRequest);
 public:
     static PassRefPtrWillBeRawPtr<DirectoryContentRequest> create(PassRefPtr<RequestDirectoryContentCallback> requestCallback, const String& url)
     {
         return adoptRefWillBeNoop(new DirectoryContentRequest(requestCallback, url));
     }
@@ skipping 12 matching lines @@
 private:
     bool didHitError(FileError* error)
     {
         reportResult(error->code());
         return true;
     }
 
     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);
     }
 
     DirectoryContentRequest(PassRefPtr<RequestDirectoryContentCallback> requestCallback, const String& url)
         : m_requestCallback(requestCallback)
         , m_url(ParsedURLString, url) { }
 
     void readDirectoryEntries();
 
     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;
 };
 
 void DirectoryContentRequest::start(ExecutionContext* executionContext)
 {
     ASSERT(executionContext);
 
     ErrorCallback* errorCallback = CallbackDispatcherFactory<ErrorCallback>::create(this, &DirectoryContentRequest::didHitError);
     EntryCallback* successCallback = CallbackDispatcherFactory<EntryCallback>::create(this, &DirectoryContentRequest::didGetEntry);
 
@@ skipping 23 matching lines @@
     }
 
     EntriesCallback* successCallback = CallbackDispatcherFactory<EntriesCallback>::create(this, &DirectoryContentRequest::didReadDirectoryEntries);
     ErrorCallback* errorCallback = CallbackDispatcherFactory<ErrorCallback>::create(this, &DirectoryContentRequest::didHitError);
     m_directoryReader->readEntries(successCallback, errorCallback);
 }
 
 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));
             }
 
             entryForFrontend->setMimeType(mimeType);
             entryForFrontend->setResourceType(resourceType);
         }
 
-        m_entries->addItem(entryForFrontend);
+        m_entries->addItem(entryForFrontend.release());
     }
     readDirectoryEntries();
     return true;
 }
 
 class MetadataRequest final : public RefCountedWillBeGarbageCollectedFinalized<MetadataRequest> {
     WTF_MAKE_NONCOPYABLE(MetadataRequest);
 public:
     static PassRefPtrWillBeRawPtr<MetadataRequest> create(PassRefPtr<RequestMetadataCallback> requestCallback, const String& url)
     {
@@ skipping 13 matching lines @@
 private:
     bool didHitError(FileError* error)
     {
         reportResult(error->code());
         return true;
     }
 
     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);
     }
 
     MetadataRequest(PassRefPtr<RequestMetadataCallback> requestCallback, const String& url)
         : m_requestCallback(requestCallback)
         , m_url(ParsedURLString, url) { }
 
     RefPtr<RequestMetadataCallback> m_requestCallback;
     KURL m_url;
@@ skipping 20 matching lines @@
     MetadataCallback* successCallback = CallbackDispatcherFactory<MetadataCallback>::create(this, &MetadataRequest::didGetMetadata);
     ErrorCallback* errorCallback = CallbackDispatcherFactory<ErrorCallback>::create(this, &MetadataRequest::didHitError);
     entry->getMetadata(successCallback, errorCallback);
     m_isDirectory = entry->isDirectory();
     return true;
 }
 
 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;
 }
 
 class FileContentRequest final : public EventListener {
     WTF_MAKE_NONCOPYABLE(FileContentRequest);
 public:
     static PassRefPtrWillBeRawPtr<FileContentRequest> create(PassRefPtr<RequestFileContentCallback> requestCallback, const String& url, bool readAsText, long long start, long long end, const String& charset)
     {
         return adoptRefWillBeNoop(new FileContentRequest(requestCallback, url, readAsText, start, end, charset));
     }
@@ skipping 29 matching lines @@
         reportResult(error->code());
         return true;
     }
 
     bool didGetEntry(Entry*);
     bool didGetFile(Blob*);
     void didRead();
 
     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)
         : EventListener(EventListener::CPPEventListenerType)
         , m_requestCallback(requestCallback)
         , m_url(ParsedURLString, url)
         , m_readAsText(readAsText)
         , m_start(start)
         , m_end(end)
         , m_charset(charset) { }
@@ skipping 200 matching lines @@
 void InspectorFileSystemAgent::disable(ErrorString*)
 {
     if (!m_enabled)
         return;
     m_enabled = false;
     m_state->setBoolean(FileSystemAgentState::fileSystemAgentEnabled, m_enabled);
 }
 
 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);
 }
 
 void InspectorFileSystemAgent::restore()
 {
     m_enabled = m_state->booleanProperty(FileSystemAgentState::fileSystemAgentEnabled, false);
 }
 
 InspectorFileSystemAgent::InspectorFileSystemAgent(InspectedFrames* inspectedFrames)
@@ skipping 24 matching lines @@
     return 0;
 }
 
 DEFINE_TRACE(InspectorFileSystemAgent)
 {
     visitor->trace(m_inspectedFrames);
     InspectorBaseAgent::trace(visitor);
 }
 
 } // namespace blink