Initial implementation of ServiceWorkerGlobalScope.fetch()

Source/modules/serviceworkers/FetchManager.cpp

Index: Source/modules/serviceworkers/FetchManager.cpp
diff --git a/Source/modules/serviceworkers/FetchManager.cpp b/Source/modules/serviceworkers/FetchManager.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..97ea913c47f7ba9b35a98bf8036a581fc28cc160
--- /dev/null
+++ b/Source/modules/serviceworkers/FetchManager.cpp
@@ -0,0 +1,163 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "config.h"
+#include "FetchManager.h"
+
+#include "bindings/v8/ScriptPromiseResolverWithContext.h"
+#include "core/dom/DOMError.h"

[yhirano, 2014/06/11 06:51:30]

DOMError is now not used.

[horo, 2014/06/11 09:06:23]

Done.

+#include "core/dom/ExceptionCode.h"
+#include "core/fileapi/Blob.h"
+#include "core/loader/ThreadableLoader.h"
+#include "core/loader/ThreadableLoaderClient.h"
+#include "modules/serviceworkers/Response.h"
+#include "wtf/HashSet.h"
+
+namespace WebCore {
+
+class FetchManager::Loader : public ThreadableLoaderClient {
+public:
+    Loader(ExecutionContext*, FetchManager*, PassRefPtr<ScriptPromiseResolverWithContext>, PassOwnPtr<ResourceRequest>);
+    ~Loader();
+    virtual void didReceiveResponse(unsigned long, const ResourceResponse&);
+    virtual void didFinishLoading(unsigned long, double);
+    virtual void didFail(const ResourceError&);
+    virtual void didFailAccessControlCheck(const ResourceError&);
+    virtual void didFailRedirectCheck();
+    virtual void didDownloadData(int);
+
+    void start();
+    void cleanup();
+
+private:
+    void failed();
+    void notiyfyFinished();
+
+    ExecutionContext* m_executionContext;
+    FetchManager* m_fetchManager;
+    RefPtr<ScriptPromiseResolverWithContext> m_resolver;
+    OwnPtr<ResourceRequest> m_request;
+    RefPtr<ThreadableLoader> m_loader;
+    ResourceResponse m_response;
+    long long m_downloadedBlobLength;
+};
+
+FetchManager::Loader::Loader(ExecutionContext* executionContext, FetchManager* fetchManager, PassRefPtr<ScriptPromiseResolverWithContext> resolver, PassOwnPtr<ResourceRequest> request)
+    : m_executionContext(executionContext)
+    , m_fetchManager(fetchManager)
+    , m_resolver(resolver)
+    , m_request(request)
+    , m_downloadedBlobLength(0)
+{
+}
+
+FetchManager::Loader::~Loader()
+{
+    if (m_loader)
+        m_loader->cancel();
+}
+
+void FetchManager::Loader::didReceiveResponse(unsigned long, const ResourceResponse& response)
+{
+    m_response = response;
+}
+
+void FetchManager::Loader::didFinishLoading(unsigned long, double)
+{
+    OwnPtr<BlobData> blobData = BlobData::create();
+    String filePath = m_response.downloadedFilePath();
+    if (!filePath.isEmpty() && m_downloadedBlobLength) {
+        blobData->appendFile(filePath);
+        // TODO(horo): Set the ContentType correctly.
+    }
+    Dictionary options;
+    // TODO(horo): fill options.
+    RefPtrWillBeRawPtr<Blob> blob = Blob::create(BlobDataHandle::create(blobData.release(), m_downloadedBlobLength));
+    // TODO(horo): Handle response status correctly.
+    m_resolver->resolve(Response::create(blob.get(), options));
+    notiyfyFinished();
+}
+
+void FetchManager::Loader::didFail(const ResourceError& error)
+{
+    failed();

[tyoshino (SeeGerritForStatus), 2014/06/11 09:12:01]

I suggest that you have a flag e.g. m_failed to ensure duplicated failed() call
won't happen.

[horo, 2014/06/11 11:22:12]

Done.

+}
+
+void FetchManager::Loader::didFailAccessControlCheck(const ResourceError& error)
+{
+    failed();
+}
+
+void FetchManager::Loader::didFailRedirectCheck()
+{
+    failed();
+}
+
+void FetchManager::Loader::didDownloadData(int dataLength)
+{
+    m_downloadedBlobLength += dataLength;
+}
+
+void FetchManager::Loader::start()
+{
+    m_request->setDownloadToFile(true);
+    ThreadableLoaderOptions options;
+    // TODO(horo): Fill options.
+    ResourceLoaderOptions resourceLoaderOptions;
+    resourceLoaderOptions.dataBufferingPolicy = DoNotBufferData;
+    // TODO(horo): Fill resourceLoaderOptions.
+    m_loader = ThreadableLoader::create(*m_executionContext, this, *m_request, options, resourceLoaderOptions);
+    if (!m_loader)
+        m_resolver->reject(DOMException::create(InvalidStateError));

[tyoshino (SeeGerritForStatus), 2014/06/11 09:12:01]

maybe this also should be TypeError. is there any spec about this?

[horo, 2014/06/11 11:22:12]

Deleted this lines.
m_executionContext->isWorkerGlobalScope() is true, so ThreadableLoader::create()
returns WorkerThreadableLoader::create() which doesn't return null.

+}
+
+void FetchManager::Loader::cleanup()
+{
+    m_fetchManager = 0;

[tyoshino (SeeGerritForStatus), 2014/06/11 09:12:01]

add comment like "prevent notification"

[horo, 2014/06/11 11:22:11]

Done.

+    if (m_loader) {
+        m_loader->cancel();
+        m_loader.clear();
+    }
+}
+
+void FetchManager::Loader::failed()
+{
+    m_resolver->reject(DOMException::create(NetworkError));

[tyoshino (SeeGerritForStatus), 2014/06/11 09:12:01]

This should be a TypeError. I also had doubts and asked Anne about this at
public-webapps.

[horo, 2014/06/11 11:22:11]

Could you please let me know how to create TypeError here?
When I call "DOMError::create(TypeError)", it crashes at ASSERT in
DOMException::getErrorName().
When I call "DOMException::create(TypeError)", it crashes at ASSERT in
DOMException::create().
When I call "V8ThrowException::createTypeError("Fetch error",
m_resolver->scriptState()->isolate())". it crashes in
WebCore::reportFatalErrorInWorker.
  1  WebCore::reportFatalErrorInWorker(char const*, char const*)
  2  v8::Utils::ReportApiFailure(char const*, char const*)
  3  v8::internal::HandleScope::Extend(v8::internal::Isolate*)
  4  v8::internal::Handle<v8::internal::ExternalAsciiString>
v8::internal::Factory::New<v8::internal::ExternalAsciiString>(v8::internal::Handle<v8::internal::Map>,
v8::internal::AllocationSpace)
  5 
v8::internal::Factory::NewExternalStringFromAscii(v8::String::ExternalAsciiStringResource
const*)
  6  v8::String::NewExternal(v8::Isolate*,
v8::String::ExternalAsciiStringResource*)
  7  WebCore::makeExternalString(WTF::String const&, v8::Isolate*)
  8  WebCore::StringCache::createStringAndInsertIntoCache(WTF::StringImpl*,
v8::Isolate*)
  9  WebCore::StringCache::v8ExternalStringSlow(WTF::StringImpl*, v8::Isolate*)
  10 WebCore::StringCache::v8ExternalString(WTF::StringImpl*, v8::Isolate*)
  11 WebCore::v8String(v8::Isolate*, WTF::String const&)
  12 WebCore::V8ThrowException::createTypeError(WTF::String const&,
v8::Isolate*)

[tyoshino (SeeGerritForStatus), 2014/06/12 03:27:24]

snip

How about this?

ScriptState* state = m_resolver->scriptState();
ScriptState::Scope scope(state);
m_resolver->reject(V8ThrowException::createTypeError("Failed",
state->isolate()));

[horo, 2014/06/12 05:21:16]

Done.
Thank you.

+    notiyfyFinished();
+}
+
+void FetchManager::Loader::notiyfyFinished()

[tyoshino (SeeGerritForStatus), 2014/06/11 09:12:01]

notiyfy -> notify

[horo, 2014/06/11 11:22:12]

Done.

+{
+    if (m_fetchManager)
+        m_fetchManager->removeLoader(this);
+}
+
+FetchManager::FetchManager(ExecutionContext* executionContext)
+    : m_executionContext(executionContext)
+{
+}
+
+FetchManager::~FetchManager()
+{
+    for (HashSet<OwnPtr<Loader> >::iterator it = m_loaders.begin(); it != m_loaders.end(); ++it) {
+        (*it)->cleanup();
+    }
+}
+
+ScriptPromise FetchManager::fetch(ScriptState* scriptState, PassOwnPtr<ResourceRequest> request)
+{
+    RefPtr<ScriptPromiseResolverWithContext> resolver = ScriptPromiseResolverWithContext::create(scriptState);
+    ScriptPromise promise = resolver->promise();
+
+    OwnPtr<Loader> loader(adoptPtr(new Loader(m_executionContext, this, resolver, request)));

[tyoshino (SeeGerritForStatus), 2014/06/11 09:12:01]

resolver.release()

[horo, 2014/06/11 11:22:12]

Done.

+    (*m_loaders.add(loader.release()).storedValue)->start();
+    return promise;
+}
+
+void FetchManager::removeLoader(Loader* loader)

[tyoshino (SeeGerritForStatus), 2014/06/11 09:12:01]

how about naming this like onLoaderFinished?

[horo, 2014/06/11 11:22:11]

Done.

+{
+    m_loaders.remove(loader);
+}
+
+} // namespace WebCore