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

   1 /*
   2  * Copyright (C) 2011, 2012 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include "config.h"
  32 #include "modules/filesystem/InspectorFileSystemAgent.h"
  33
  34 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
  35 #include "bindings/core/v8/UnionTypesCore.h"
  36 #include "core/dom/DOMArrayBuffer.h"
  37 #include "core/dom/DOMImplementation.h"
  38 #include "core/dom/Document.h"
  39 #include "core/events/Event.h"
  40 #include "core/fileapi/File.h"
  41 #include "core/fileapi/FileCallback.h"
  42 #include "core/fileapi/FileError.h"
  43 #include "core/fileapi/FileReader.h"
  44 #include "core/frame/LocalFrame.h"
  45 #include "core/html/HTMLMediaElement.h"
  46 #include "core/html/VoidCallback.h"
  47 #include "core/html/parser/TextResourceDecoder.h"
  48 #include "core/inspector/InspectorState.h"
  49 #include "core/page/Page.h"
  50 #include "modules/filesystem/DOMFileSystem.h"
  51 #include "modules/filesystem/DirectoryEntry.h"
  52 #include "modules/filesystem/DirectoryReader.h"
  53 #include "modules/filesystem/EntriesCallback.h"
  54 #include "modules/filesystem/Entry.h"
  55 #include "modules/filesystem/EntryCallback.h"
  56 #include "modules/filesystem/ErrorCallback.h"
  57 #include "modules/filesystem/FileEntry.h"
  58 #include "modules/filesystem/FileSystemCallbacks.h"
  59 #include "modules/filesystem/LocalFileSystem.h"
  60 #include "modules/filesystem/Metadata.h"
  61 #include "modules/filesystem/MetadataCallback.h"
  62 #include "platform/ContentType.h"
  63 #include "platform/MIMETypeRegistry.h"
  64 #include "platform/heap/Handle.h"
  65 #include "platform/weborigin/KURL.h"
  66 #include "platform/weborigin/SecurityOrigin.h"
  67 #include "wtf/text/Base64.h"
  68 #include "wtf/text/TextEncoding.h"
  69
  70 using blink::TypeBuilder::Array;
  71
  72 typedef blink::InspectorBackendDispatcher::FileSystemCommandHandler::RequestFileSystemRootCallback RequestFileSystemRootCallback;
  73 typedef blink::InspectorBackendDispatcher::FileSystemCommandHandler::RequestDirectoryContentCallback RequestDirectoryContentCallback;
  74 typedef blink::InspectorBackendDispatcher::FileSystemCommandHandler::RequestMetadataCallback RequestMetadataCallback;
  75 typedef blink::InspectorBackendDispatcher::FileSystemCommandHandler::RequestFileContentCallback RequestFileContentCallback;
  76 typedef blink::InspectorBackendDispatcher::FileSystemCommandHandler::DeleteEntryCallback DeleteEntryCallback;
  77
  78 namespace blink {
  79
  80 namespace FileSystemAgentState {
  81 static const char fileSystemAgentEnabled[] = "fileSystemAgentEnabled";
  82 }
  83
  84 namespace {
  85
  86 template<typename BaseCallback, typename Handler, typename Argument>
  87 class GC_PLUGIN_IGNORE("crbug.com/513077") CallbackDispatcher final : public BaseCallback {
  88 public:
  89     typedef bool (Handler::*HandlingMethod)(Argument);
  90
  91     static CallbackDispatcher* create(PassRefPtrWillBeRawPtr<Handler> handler, HandlingMethod handlingMethod)
  92     {
  93         return new CallbackDispatcher(handler, handlingMethod);
  94     }
  95
  96     void handleEvent(Argument argument) override
  97     {
  98         (m_handler.get()->*m_handlingMethod)(argument);
  99     }
 100
 101     DEFINE_INLINE_TRACE()
 102     {
 103         visitor->trace(m_handler);
 104         BaseCallback::trace(visitor);
 105     }
 106
 107 private:
 108     CallbackDispatcher(PassRefPtrWillBeRawPtr<Handler> handler, HandlingMethod handlingMethod)
 109         : m_handler(handler)
 110         , m_handlingMethod(handlingMethod) { }
 111
 112     RefPtrWillBeMember<Handler> m_handler;
 113     HandlingMethod m_handlingMethod;
 114 };
 115
 116 template<typename BaseCallback>
 117 class CallbackDispatcherFactory {
 118 public:
 119     template<typename Handler, typename Argument>
 120     static CallbackDispatcher<BaseCallback, Handler, Argument>* create(Handler* handler, bool (Handler::*handlingMethod)(Argument))
 121     {
 122         return CallbackDispatcher<BaseCallback, Handler, Argument>::create(PassRefPtrWillBeRawPtr<Handler>(handler), handlingMethod);
 123     }
 124 };
 125
 126 class FileSystemRootRequest final : public RefCountedWillBeGarbageCollectedFinalized<FileSystemRootRequest> {
 127     WTF_MAKE_NONCOPYABLE(FileSystemRootRequest);
 128 public:
 129     static PassRefPtrWillBeRawPtr<FileSystemRootRequest> create(PassRefPtrWillBeRawPtr<RequestFileSystemRootCallback> requestCallback, const String& type)
 130     {
 131         return adoptRefWillBeNoop(new FileSystemRootRequest(requestCallback, type));
 132     }
 133
 134     void start(ExecutionContext*);
 135
 136     DEFINE_INLINE_TRACE()
 137     {
 138         visitor->trace(m_requestCallback);
 139     }
 140
 141 private:
 142     bool didHitError(FileError* error)
 143     {
 144         reportResult(error->code());
 145         return true;
 146     }
 147
 148     bool didGetEntry(Entry*);
 149
 150     void reportResult(FileError::ErrorCode errorCode, PassRefPtr<TypeBuilder::FileSystem::Entry> entry = nullptr)
 151     {
 152         m_requestCallback->sendSuccess(static_cast<int>(errorCode), entry);
 153     }
 154
 155     FileSystemRootRequest(PassRefPtrWillBeRawPtr<RequestFileSystemRootCallback> requestCallback, const String& type)
 156         : m_requestCallback(requestCallback)
 157         , m_type(type) { }
 158
 159     RefPtrWillBeMember<RequestFileSystemRootCallback> m_requestCallback;
 160     String m_type;
 161 };
 162
 163 void FileSystemRootRequest::start(ExecutionContext* executionContext)
 164 {
 165     ASSERT(executionContext);
 166
 167     ErrorCallback* errorCallback = CallbackDispatcherFactory<ErrorCallback>::create(this, &FileSystemRootRequest::didHitError);
 168
 169     FileSystemType type;
 170     if (!DOMFileSystemBase::pathPrefixToFileSystemType(m_type, type)) {
 171         errorCallback->handleEvent(FileError::create(FileError::SYNTAX_ERR));
 172         return;
 173     }
 174
 175     KURL rootURL = DOMFileSystemBase::createFileSystemRootURL(executionContext->securityOrigin()->toString(), type);
 176     if (!rootURL.isValid()) {
 177         errorCallback->handleEvent(FileError::create(FileError::SYNTAX_ERR));
 178         return;
 179     }
 180
 181     EntryCallback* successCallback = CallbackDispatcherFactory<EntryCallback>::create(this, &FileSystemRootRequest::didGetEntry);
 182     OwnPtr<AsyncFileSystemCallbacks> fileSystemCallbacks = ResolveURICallbacks::create(successCallback, errorCallback, executionContext);
 183     LocalFileSystem::from(*executionContext)->resolveURL(executionContext, rootURL, fileSystemCallbacks.release());
 184 }
 185
 186 bool FileSystemRootRequest::didGetEntry(Entry* entry)
 187 {
 188     RefPtr<TypeBuilder::FileSystem::Entry> result = TypeBuilder::FileSystem::Entry::create()
 189         .setUrl(entry->toURL())
 190         .setName("/")
 191         .setIsDirectory(true);
 192     reportResult(static_cast<FileError::ErrorCode>(0), result);
 193     return true;
 194 }
 195
 196 class DirectoryContentRequest final : public RefCountedWillBeGarbageCollectedFinalized<DirectoryContentRequest> {
 197     WTF_MAKE_NONCOPYABLE(DirectoryContentRequest);
 198 public:
 199     static PassRefPtrWillBeRawPtr<DirectoryContentRequest> create(PassRefPtrWillBeRawPtr<RequestDirectoryContentCallback> requestCallback, const String& url)
 200     {
 201         return adoptRefWillBeNoop(new DirectoryContentRequest(requestCallback, url));
 202     }
 203
 204     ~DirectoryContentRequest()
 205     {
 206     }
 207
 208     void start(ExecutionContext*);
 209
 210     DEFINE_INLINE_VIRTUAL_TRACE()
 211     {
 212         visitor->trace(m_requestCallback);
 213         visitor->trace(m_directoryReader);
 214     }
 215
 216 private:
 217     bool didHitError(FileError* error)
 218     {
 219         reportResult(error->code());
 220         return true;
 221     }
 222
 223     bool didGetEntry(Entry*);
 224     bool didReadDirectoryEntries(const EntryHeapVector&);
 225
 226     void reportResult(FileError::ErrorCode errorCode, PassRefPtr<Array<TypeBuilder::FileSystem::Entry>> entries = nullptr)
 227     {
 228         m_requestCallback->sendSuccess(static_cast<int>(errorCode), entries);
 229     }
 230
 231     DirectoryContentRequest(PassRefPtrWillBeRawPtr<RequestDirectoryContentCallback> requestCallback, const String& url)
 232         : m_requestCallback(requestCallback)
 233         , m_url(ParsedURLString, url) { }
 234
 235     void readDirectoryEntries();
 236
 237     RefPtrWillBeMember<RequestDirectoryContentCallback> m_requestCallback;
 238     KURL m_url;
 239     RefPtr<Array<TypeBuilder::FileSystem::Entry>> m_entries;
 240     PersistentWillBeMember<DirectoryReader> m_directoryReader;
 241 };
 242
 243 void DirectoryContentRequest::start(ExecutionContext* executionContext)
 244 {
 245     ASSERT(executionContext);
 246
 247     ErrorCallback* errorCallback = CallbackDispatcherFactory<ErrorCallback>::create(this, &DirectoryContentRequest::didHitError);
 248     EntryCallback* successCallback = CallbackDispatcherFactory<EntryCallback>::create(this, &DirectoryContentRequest::didGetEntry);
 249
 250     OwnPtr<AsyncFileSystemCallbacks> fileSystemCallbacks = ResolveURICallbacks::create(successCallback, errorCallback, executionContext);
 251
 252     LocalFileSystem::from(*executionContext)->resolveURL(executionContext, m_url, fileSystemCallbacks.release());
 253 }
 254
 255 bool DirectoryContentRequest::didGetEntry(Entry* entry)
 256 {
 257     if (!entry->isDirectory()) {
 258         reportResult(FileError::TYPE_MISMATCH_ERR);
 259         return true;
 260     }
 261
 262     m_directoryReader = toDirectoryEntry(entry)->createReader();
 263     m_entries = Array<TypeBuilder::FileSystem::Entry>::create();
 264     readDirectoryEntries();
 265     return true;
 266 }
 267
 268 void DirectoryContentRequest::readDirectoryEntries()
 269 {
 270     if (!m_directoryReader->filesystem()->executionContext()) {
 271         reportResult(FileError::ABORT_ERR);
 272         return;
 273     }
 274
 275     EntriesCallback* successCallback = CallbackDispatcherFactory<EntriesCallback>::create(this, &DirectoryContentRequest::didReadDirectoryEntries);
 276     ErrorCallback* errorCallback = CallbackDispatcherFactory<ErrorCallback>::create(this, &DirectoryContentRequest::didHitError);
 277     m_directoryReader->readEntries(successCallback, errorCallback);
 278 }
 279
 280 bool DirectoryContentRequest::didReadDirectoryEntries(const EntryHeapVector& entries)
 281 {
 282     if (entries.isEmpty()) {
 283         reportResult(static_cast<FileError::ErrorCode>(0), m_entries);
 284         return true;
 285     }
 286
 287     for (size_t i = 0; i < entries.size(); ++i) {
 288         Entry* entry = entries[i];
 289         RefPtr<TypeBuilder::FileSystem::Entry> entryForFrontend = TypeBuilder::FileSystem::Entry::create()
 290             .setUrl(entry->toURL())
 291             .setName(entry->name())
 292             .setIsDirectory(entry->isDirectory());
 293
 294         using TypeBuilder::Page::ResourceType;
 295         if (!entry->isDirectory()) {
 296             String mimeType = MIMETypeRegistry::getMIMETypeForPath(entry->name());
 297             ResourceType::Enum resourceType;
 298             if (MIMETypeRegistry::isSupportedImageMIMEType(mimeType)) {
 299                 resourceType = ResourceType::Image;
 300                 entryForFrontend->setIsTextFile(false);
 301             } else if (HTMLMediaElement::supportsType(ContentType(mimeType)) != WebMimeRegistry::IsNotSupported) {
 302                 resourceType = ResourceType::Media;
 303                 entryForFrontend->setIsTextFile(false);
 304             } else if (MIMETypeRegistry::isSupportedJavaScriptMIMEType(mimeType)) {
 305                 resourceType = ResourceType::Script;
 306                 entryForFrontend->setIsTextFile(true);
 307             } else if (MIMETypeRegistry::isSupportedNonImageMIMEType(mimeType)) {
 308                 resourceType = ResourceType::Document;
 309                 entryForFrontend->setIsTextFile(true);
 310             } else {
 311                 resourceType = ResourceType::Other;
 312                 entryForFrontend->setIsTextFile(DOMImplementation::isXMLMIMEType(mimeType) || DOMImplementation::isTextMIMEType(mimeType));
 313             }
 314
 315             entryForFrontend->setMimeType(mimeType);
 316             entryForFrontend->setResourceType(resourceType);
 317         }
 318
 319         m_entries->addItem(entryForFrontend);
 320     }
 321     readDirectoryEntries();
 322     return true;
 323 }
 324
 325 class MetadataRequest final : public RefCountedWillBeGarbageCollectedFinalized<MetadataRequest> {
 326     WTF_MAKE_NONCOPYABLE(MetadataRequest);
 327 public:
 328     static PassRefPtrWillBeRawPtr<MetadataRequest> create(PassRefPtrWillBeRawPtr<RequestMetadataCallback> requestCallback, const String& url)
 329     {
 330         return adoptRefWillBeNoop(new MetadataRequest(requestCallback, url));
 331     }
 332
 333     ~MetadataRequest()
 334     {
 335     }
 336
 337     void start(ExecutionContext*);
 338
 339     DEFINE_INLINE_VIRTUAL_TRACE()
 340     {
 341         visitor->trace(m_requestCallback);
 342     }
 343
 344 private:
 345     bool didHitError(FileError* error)
 346     {
 347         reportResult(error->code());
 348         return true;
 349     }
 350
 351     bool didGetEntry(Entry*);
 352     bool didGetMetadata(Metadata*);
 353
 354     void reportResult(FileError::ErrorCode errorCode, PassRefPtr<TypeBuilder::FileSystem::Metadata> metadata = nullptr)
 355     {
 356         m_requestCallback->sendSuccess(static_cast<int>(errorCode), metadata);
 357     }
 358
 359     MetadataRequest(PassRefPtrWillBeRawPtr<RequestMetadataCallback> requestCallback, const String& url)
 360         : m_requestCallback(requestCallback)
 361         , m_url(ParsedURLString, url) { }
 362
 363     RefPtrWillBeMember<RequestMetadataCallback> m_requestCallback;
 364     KURL m_url;
 365     bool m_isDirectory;
 366 };
 367
 368 void MetadataRequest::start(ExecutionContext* executionContext)
 369 {
 370     ASSERT(executionContext);
 371
 372     ErrorCallback* errorCallback = CallbackDispatcherFactory<ErrorCallback>::create(this, &MetadataRequest::didHitError);
 373     EntryCallback* successCallback = CallbackDispatcherFactory<EntryCallback>::create(this, &MetadataRequest::didGetEntry);
 374     OwnPtr<AsyncFileSystemCallbacks> fileSystemCallbacks = ResolveURICallbacks::create(successCallback, errorCallback, executionContext);
 375     LocalFileSystem::from(*executionContext)->resolveURL(executionContext, m_url, fileSystemCallbacks.release());
 376 }
 377
 378 bool MetadataRequest::didGetEntry(Entry* entry)
 379 {
 380     if (!entry->filesystem()->executionContext()) {
 381         reportResult(FileError::ABORT_ERR);
 382         return true;
 383     }
 384
 385     MetadataCallback* successCallback = CallbackDispatcherFactory<MetadataCallback>::create(this, &MetadataRequest::didGetMetadata);
 386     ErrorCallback* errorCallback = CallbackDispatcherFactory<ErrorCallback>::create(this, &MetadataRequest::didHitError);
 387     entry->getMetadata(successCallback, errorCallback);
 388     m_isDirectory = entry->isDirectory();
 389     return true;
 390 }
 391
 392 bool MetadataRequest::didGetMetadata(Metadata* metadata)
 393 {
 394     using TypeBuilder::FileSystem::Metadata;
 395     RefPtr<Metadata> result = Metadata::create()
 396         .setModificationTime(metadata->modificationTime())
 397         .setSize(metadata->size());
 398     reportResult(static_cast<FileError::ErrorCode>(0), result);
 399     return true;
 400 }
 401
 402 class FileContentRequest final : public EventListener {
 403     WTF_MAKE_NONCOPYABLE(FileContentRequest);
 404 public:
 405     static PassRefPtrWillBeRawPtr<FileContentRequest> create(PassRefPtrWillBeRawPtr<RequestFileContentCallback> requestCallback, const String& url, bool readAsText, long long start, long long end, const String& charset)
 406     {
 407         return adoptRefWillBeNoop(new FileContentRequest(requestCallback, url, readAsText, start, end, charset));
 408     }
 409
 410     ~FileContentRequest() override
 411     {
 412     }
 413
 414     void start(ExecutionContext*);
 415
 416     bool operator==(const EventListener& other) override
 417     {
 418         return this == &other;
 419     }
 420
 421     void handleEvent(ExecutionContext*, Event* event) override
 422     {
 423         if (event->type() == EventTypeNames::load)
 424             didRead();
 425         else if (event->type() == EventTypeNames::error)
 426             didHitError(m_reader->error());
 427     }
 428
 429     DEFINE_INLINE_VIRTUAL_TRACE()
 430     {
 431         visitor->trace(m_requestCallback);
 432         visitor->trace(m_reader);
 433         EventListener::trace(visitor);
 434     }
 435
 436 private:
 437     bool didHitError(FileError* error)
 438     {
 439         reportResult(error->code());
 440         return true;
 441     }
 442
 443     bool didGetEntry(Entry*);
 444     bool didGetFile(File*);
 445     void didRead();
 446
 447     void reportResult(FileError::ErrorCode errorCode, const String* result = 0, const String* charset = 0)
 448     {
 449         m_requestCallback->sendSuccess(static_cast<int>(errorCode), result, charset);
 450     }
 451
 452     FileContentRequest(PassRefPtrWillBeRawPtr<RequestFileContentCallback> requestCallback, const String& url, bool readAsText, long long start, long long end, const String& charset)
 453         : EventListener(EventListener::CPPEventListenerType)
 454         , m_requestCallback(requestCallback)
 455         , m_url(ParsedURLString, url)
 456         , m_readAsText(readAsText)
 457         , m_start(start)
 458         , m_end(end)
 459         , m_charset(charset) { }
 460
 461     RefPtrWillBeMember<RequestFileContentCallback> m_requestCallback;
 462     KURL m_url;
 463     bool m_readAsText;
 464     int m_start;
 465     long long m_end;
 466     String m_mimeType;
 467     String m_charset;
 468
 469     PersistentWillBeMember<FileReader> m_reader;
 470 };
 471
 472 void FileContentRequest::start(ExecutionContext* executionContext)
 473 {
 474     ASSERT(executionContext);
 475
 476     ErrorCallback* errorCallback = CallbackDispatcherFactory<ErrorCallback>::create(this, &FileContentRequest::didHitError);
 477     EntryCallback* successCallback = CallbackDispatcherFactory<EntryCallback>::create(this, &FileContentRequest::didGetEntry);
 478
 479     OwnPtr<AsyncFileSystemCallbacks> fileSystemCallbacks = ResolveURICallbacks::create(successCallback, errorCallback, executionContext);
 480     LocalFileSystem::from(*executionContext)->resolveURL(executionContext, m_url, fileSystemCallbacks.release());
 481 }
 482
 483 bool FileContentRequest::didGetEntry(Entry* entry)
 484 {
 485     if (entry->isDirectory()) {
 486         reportResult(FileError::TYPE_MISMATCH_ERR);
 487         return true;
 488     }
 489
 490     if (!entry->filesystem()->executionContext()) {
 491         reportResult(FileError::ABORT_ERR);
 492         return true;
 493     }
 494
 495     FileCallback* successCallback = CallbackDispatcherFactory<FileCallback>::create(this, &FileContentRequest::didGetFile);
 496     ErrorCallback* errorCallback = CallbackDispatcherFactory<ErrorCallback>::create(this, &FileContentRequest::didHitError);
 497     toFileEntry(entry)->file(successCallback, errorCallback);
 498
 499     m_reader = FileReader::create(entry->filesystem()->executionContext());
 500     m_mimeType = MIMETypeRegistry::getMIMETypeForPath(entry->name());
 501
 502     return true;
 503 }
 504
 505 bool FileContentRequest::didGetFile(File* file)
 506 {
 507     Blob* blob = file->Blob::slice(m_start, m_end, IGNORE_EXCEPTION);
 508     m_reader->setOnload(this);
 509     m_reader->setOnerror(this);
 510
 511     m_reader->readAsArrayBuffer(blob, IGNORE_EXCEPTION);
 512     return true;
 513 }
 514
 515 void FileContentRequest::didRead()
 516 {
 517     StringOrArrayBuffer resultAttribute;
 518     m_reader->result(resultAttribute);
 519     RefPtr<DOMArrayBuffer> buffer = resultAttribute.getAsArrayBuffer();
 520
 521     if (!m_readAsText) {
 522         String result = base64Encode(static_cast<char*>(buffer->data()), buffer->byteLength());
 523         reportResult(static_cast<FileError::ErrorCode>(0), &result, 0);
 524         return;
 525     }
 526
 527     OwnPtr<TextResourceDecoder> decoder = TextResourceDecoder::create(m_mimeType, m_charset, true);
 528     String result = decoder->decode(static_cast<char*>(buffer->data()), buffer->byteLength());
 529     result = result + decoder->flush();
 530     m_charset = decoder->encoding().name();
 531     reportResult(static_cast<FileError::ErrorCode>(0), &result, &m_charset);
 532 }
 533
 534 class DeleteEntryRequest final : public RefCountedWillBeGarbageCollectedFinalized<DeleteEntryRequest> {
 535 public:
 536     static PassRefPtrWillBeRawPtr<DeleteEntryRequest> create(PassRefPtrWillBeRawPtr<DeleteEntryCallback> requestCallback, const KURL& url)
 537     {
 538         return adoptRefWillBeNoop(new DeleteEntryRequest(requestCallback, url));
 539     }
 540
 541     ~DeleteEntryRequest()
 542     {
 543     }
 544
 545     void start(ExecutionContext*);
 546
 547     DEFINE_INLINE_TRACE()
 548     {
 549         visitor->trace(m_requestCallback);
 550     }
 551
 552 private:
 553     // CallbackDispatcherFactory doesn't handle 0-arg handleEvent methods
 554     class VoidCallbackImpl final : public VoidCallback {
 555     public:
 556         explicit VoidCallbackImpl(PassRefPtrWillBeRawPtr<DeleteEntryRequest> handler)
 557             : m_handler(handler)
 558         {
 559         }
 560
 561         void handleEvent() override
 562         {
 563             m_handler->didDeleteEntry();
 564         }
 565
 566         DEFINE_INLINE_VIRTUAL_TRACE()
 567         {
 568             visitor->trace(m_handler);
 569             VoidCallback::trace(visitor);
 570         }
 571
 572     private:
 573         RefPtrWillBeMember<DeleteEntryRequest> m_handler;
 574     };
 575
 576     bool didHitError(FileError* error)
 577     {
 578         reportResult(error->code());
 579         return true;
 580     }
 581
 582     bool didGetEntry(Entry*);
 583     bool didDeleteEntry();
 584
 585     void reportResult(FileError::ErrorCode errorCode)
 586     {
 587         m_requestCallback->sendSuccess(static_cast<int>(errorCode));
 588     }
 589
 590     DeleteEntryRequest(PassRefPtrWillBeRawPtr<DeleteEntryCallback> requestCallback, const KURL& url)
 591         : m_requestCallback(requestCallback)
 592         , m_url(url) { }
 593
 594     RefPtrWillBeMember<DeleteEntryCallback> m_requestCallback;
 595     KURL m_url;
 596 };
 597
 598 void DeleteEntryRequest::start(ExecutionContext* executionContext)
 599 {
 600     ASSERT(executionContext);
 601
 602     ErrorCallback* errorCallback = CallbackDispatcherFactory<ErrorCallback>::create(this, &DeleteEntryRequest::didHitError);
 603
 604     FileSystemType type;
 605     String path;
 606     if (!DOMFileSystemBase::crackFileSystemURL(m_url, type, path)) {
 607         errorCallback->handleEvent(FileError::create(FileError::SYNTAX_ERR));
 608         return;
 609     }
 610
 611     if (path == "/") {
 612         VoidCallback* successCallback = new VoidCallbackImpl(this);
 613         OwnPtr<AsyncFileSystemCallbacks> fileSystemCallbacks = VoidCallbacks::create(successCallback, errorCallback, executionContext, nullptr);
 614         LocalFileSystem::from(*executionContext)->deleteFileSystem(executionContext, type, fileSystemCallbacks.release());
 615     } else {
 616         EntryCallback* successCallback = CallbackDispatcherFactory<EntryCallback>::create(this, &DeleteEntryRequest::didGetEntry);
 617         OwnPtr<AsyncFileSystemCallbacks> fileSystemCallbacks = ResolveURICallbacks::create(successCallback, errorCallback, executionContext);
 618         LocalFileSystem::from(*executionContext)->resolveURL(executionContext, m_url, fileSystemCallbacks.release());
 619     }
 620 }
 621
 622 bool DeleteEntryRequest::didGetEntry(Entry* entry)
 623 {
 624     VoidCallback* successCallback = new VoidCallbackImpl(this);
 625     ErrorCallback* errorCallback = CallbackDispatcherFactory<ErrorCallback>::create(this, &DeleteEntryRequest::didHitError);
 626     if (entry->isDirectory()) {
 627         DirectoryEntry* directoryEntry = toDirectoryEntry(entry);
 628         directoryEntry->removeRecursively(successCallback, errorCallback);
 629     } else {
 630         entry->remove(successCallback, errorCallback);
 631     }
 632     return true;
 633 }
 634
 635 bool DeleteEntryRequest::didDeleteEntry()
 636 {
 637     reportResult(static_cast<FileError::ErrorCode>(0));
 638     return true;
 639 }
 640
 641 } // anonymous namespace
 642
 643 // static
 644 PassOwnPtrWillBeRawPtr<InspectorFileSystemAgent> InspectorFileSystemAgent::create(Page* page)
 645 {
 646     return adoptPtrWillBeNoop(new InspectorFileSystemAgent(page));
 647 }
 648
 649 InspectorFileSystemAgent::~InspectorFileSystemAgent()
 650 {
 651 }
 652
 653 void InspectorFileSystemAgent::enable(ErrorString*)
 654 {
 655     if (m_enabled)
 656         return;
 657     m_enabled = true;
 658     m_state->setBoolean(FileSystemAgentState::fileSystemAgentEnabled, m_enabled);
 659 }
 660
 661 void InspectorFileSystemAgent::disable(ErrorString*)
 662 {
 663     if (!m_enabled)
 664         return;
 665     m_enabled = false;
 666     m_state->setBoolean(FileSystemAgentState::fileSystemAgentEnabled, m_enabled);
 667 }
 668
 669 void InspectorFileSystemAgent::requestFileSystemRoot(ErrorString* error, const String& origin, const String& type, PassRefPtrWillBeRawPtr<RequestFileSystemRootCallback> requestCallback)
 670 {
 671     if (!assertEnabled(error))
 672         return;
 673
 674     ExecutionContext* executionContext = assertExecutionContextForOrigin(error, SecurityOrigin::createFromString(origin).get());
 675     if (!executionContext)
 676         return;
 677
 678     FileSystemRootRequest::create(requestCallback, type)->start(executionContext);
 679 }
 680
 681 void InspectorFileSystemAgent::requestDirectoryContent(ErrorString* error, const String& url, PassRefPtrWillBeRawPtr<RequestDirectoryContentCallback> requestCallback)
 682 {
 683     if (!assertEnabled(error))
 684         return;
 685
 686     ExecutionContext* executionContext = assertExecutionContextForOrigin(error, SecurityOrigin::createFromString(url).get());
 687     if (!executionContext)
 688         return;
 689
 690     DirectoryContentRequest::create(requestCallback, url)->start(executionContext);
 691 }
 692
 693 void InspectorFileSystemAgent::requestMetadata(ErrorString* error, const String& url, PassRefPtrWillBeRawPtr<RequestMetadataCallback> requestCallback)
 694 {
 695     if (!assertEnabled(error))
 696         return;
 697
 698     ExecutionContext* executionContext = assertExecutionContextForOrigin(error, SecurityOrigin::createFromString(url).get());
 699     if (!executionContext)
 700         return;
 701
 702     MetadataRequest::create(requestCallback, url)->start(executionContext);
 703 }
 704
 705 void InspectorFileSystemAgent::requestFileContent(ErrorString* error, const String& url, bool readAsText, const int* start, const int* end, const String* charset, PassRefPtrWillBeRawPtr<RequestFileContentCallback> requestCallback)
 706 {
 707     if (!assertEnabled(error))
 708         return;
 709
 710     ExecutionContext* executionContext = assertExecutionContextForOrigin(error, SecurityOrigin::createFromString(url).get());
 711     if (!executionContext)
 712         return;
 713
 714     long long startPosition = start ? *start : 0;
 715     long long endPosition = end ? *end : std::numeric_limits<long long>::max();
 716     FileContentRequest::create(requestCallback, url, readAsText, startPosition, endPosition, charset ? *charset : "")->start(executionContext);
 717 }
 718
 719 void InspectorFileSystemAgent::deleteEntry(ErrorString* error, const String& urlString, PassRefPtrWillBeRawPtr<DeleteEntryCallback> requestCallback)
 720 {
 721     if (!assertEnabled(error))
 722         return;
 723
 724     KURL url(ParsedURLString, urlString);
 725
 726     ExecutionContext* executionContext = assertExecutionContextForOrigin(error, SecurityOrigin::create(url).get());
 727     if (!executionContext)
 728         return;
 729
 730     DeleteEntryRequest::create(requestCallback, url)->start(executionContext);
 731 }
 732
 733 void InspectorFileSystemAgent::restore()
 734 {
 735     m_enabled = m_state->getBoolean(FileSystemAgentState::fileSystemAgentEnabled);
 736 }
 737
 738 InspectorFileSystemAgent::InspectorFileSystemAgent(Page* page)
 739     : InspectorBaseAgent<InspectorFileSystemAgent, InspectorFrontend::FileSystem>("FileSystem")
 740     , m_page(page)
 741     , m_enabled(false)
 742 {
 743     ASSERT(m_page);
 744 }
 745
 746 bool InspectorFileSystemAgent::assertEnabled(ErrorString* error)
 747 {
 748     if (!m_enabled) {
 749         *error = "FileSystem agent is not enabled.";
 750         return false;
 751     }
 752     return true;
 753 }
 754
 755 ExecutionContext* InspectorFileSystemAgent::assertExecutionContextForOrigin(ErrorString* error, SecurityOrigin* origin)
 756 {
 757     for (Frame* frame = m_page->mainFrame(); frame; frame = frame->tree().traverseNext()) {
 758         if (!frame->isLocalFrame())
 759             continue;
 760         LocalFrame* localFrame = toLocalFrame(frame);
 761         if (localFrame->document() && localFrame->document()->securityOrigin()->isSameSchemeHostPort(origin))
 762             return localFrame->document();
 763     }
 764
 765     *error = "No frame is available for the request";
 766     return 0;
 767 }
 768
 769 DEFINE_TRACE(InspectorFileSystemAgent)
 770 {
 771     visitor->trace(m_page);
 772     InspectorBaseAgent::trace(visitor);
 773 }
 774
 775 } // namespace blink