Introducing the WebServiceWorkerCache.

Source/modules/serviceworkers/Response.cpp

 // 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 "Response.h"
 
 #include "bindings/core/v8/Dictionary.h"
+#include "bindings/core/v8/ExceptionState.h"
 #include "core/fileapi/Blob.h"
 #include "modules/serviceworkers/FetchBodyStream.h"
 #include "modules/serviceworkers/ResponseInit.h"
+#include "public/platform/WebServiceWorkerResponse.h"
 
 namespace blink {
 
+namespace {
+
+PassRefPtrWillBeRawPtr<FetchResponseData> createFetchResponseDataFromWebResponse(const WebServiceWorkerResponse& webResponse)
+{
+    RefPtrWillBeRawPtr<FetchResponseData> response;
+    if (webResponse.status() < 200 || webResponse.status() >= 300)

[dominicc (has gone to gerrit), 2014/08/15 06:20:24]

What about turning the cases around and doing

if (200 <= webResponse.status() && webResponse.status() < 300)

?

It's more evocative of a range. Helper method with descriptive name could also
work.

[gavinp, 2014/08/19 21:09:37]

Done.

+        response = FetchResponseData::createNetworkErrorResponse();
+    else
+        response = FetchResponseData::create();
+
+    response->setURL(webResponse.url());
+    response->setStatus(webResponse.status());
+    response->setStatusMessage(webResponse.statusText());
+    return response;
+}
+
+PassRefPtrWillBeRawPtr<Headers> createHeadersFromWebResponse(const WebServiceWorkerResponse& webResponse)
+{
+    RefPtrWillBeRawPtr<Headers> headers = Headers::create();
+    TrackExceptionState exceptionState;

[dominicc (has gone to gerrit), 2014/08/15 06:20:24]

Can you tell me how this runs JavaScript? I really want to know if there's the
potential to run user code here or what is going on.

[gavinp, 2014/08/19 21:09:37]

I wish I understood too. Horo-san, can you fill us in? Why does
Headers::append() take an exception state? This is the method to add headers,
and I have no idea why it needs this.

[jsbell, 2014/08/20 00:22:03]

Per Fetch spec, some calls throw (e.g. empty names).  Since that's web-exposed
and defined in prose not IDL, it's outside the scope of bindings and handled in
the impl.
TrackExceptionState is just a helper that ignores exceptions. e.g. if the
WebResponse data included an invalid header name.

Alternately, this could be NonThrowableExceptionState which would ASSERT if
append() throws. I assume WebResponse can include headers that user code is not
allowed to set; if not, it should use NonThrowableExceptionState.

+    for (HashMap<String, String>::const_iterator i = webResponse.headers().begin(), end = webResponse.headers().end(); i != end; ++i) {
+        headers->append(i->key, i->value, exceptionState);
+        if (exceptionState.hadException())
+            return PassRefPtrWillBeRawPtr<Headers>();
+    }
+    return headers;
+}
+
+}
+
 DEFINE_EMPTY_DESTRUCTOR_WILL_BE_REMOVED(Response);
 
 PassRefPtrWillBeRawPtr<Response> Response::create(Blob* body, const Dictionary& responseInit, ExceptionState& exceptionState)
 {
     return create(body, ResponseInit(responseInit), exceptionState);
 }
 
 PassRefPtrWillBeRawPtr<Response> Response::create(const String& body, const Dictionary& responseInit, ExceptionState& exceptionState)
 {
     OwnPtr<BlobData> blobData = BlobData::create();
@@ skipping 66 matching lines @@
 
     // "9. Return |r|."
     return r.release();
 }
 
 PassRefPtrWillBeRawPtr<Response> Response::create(PassRefPtrWillBeRawPtr<FetchResponseData> response)
 {
     return adoptRefWillBeNoop(new Response(response));
 }
 
+PassRefPtrWillBeRawPtr<Response> Response::create(const WebServiceWorkerResponse& webResponse)
+{
+    return adoptRefWillBeNoop(new Response(webResponse));
+}
+
 String Response::type() const
 {
     // "The type attribute's getter must return response's type."
     switch (m_response->type()) {
     case FetchResponseData::BasicType:
         return "basic";
     case FetchResponseData::CORSType:
         return "cors";
     case FetchResponseData::DefaultType:
         return "default";
@@ skipping 59 matching lines @@
 }
 
 Response::Response(PassRefPtrWillBeRawPtr<FetchResponseData> response)
     : m_response(response)
     , m_headers(Headers::create(m_response->headerList()))
 {
     m_headers->setGuard(Headers::ResponseGuard);
     ScriptWrappable::init(this);
 }
 
+// FIXME: Handle response body data.
+Response::Response(const WebServiceWorkerResponse& webResponse)
+    : m_response(createFetchResponseDataFromWebResponse(webResponse))
+    , m_headers(createHeadersFromWebResponse(webResponse))
+{
+    m_headers->setGuard(Headers::ResponseGuard);
+    ScriptWrappable::init(this);
+}
+
 void Response::trace(Visitor* visitor)
 {
     visitor->trace(m_response);
     visitor->trace(m_headers);
     visitor->trace(m_fetchBodyStream);
 }
 
 } // namespace blink