Fetch API: Add Request#cache attribute

third_party/WebKit/Source/modules/fetch/Request.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 "modules/fetch/Request.h"
 
 #include "bindings/core/v8/Dictionary.h"
 #include "bindings/core/v8/V8PrivateProperty.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExecutionContext.h"
@@ skipping 27 matching lines @@
   if (world.IsIsolatedWorld())
     request->SetOrigin(world.IsolatedWorldSecurityOrigin());
   else
     request->SetOrigin(
         script_state->GetExecutionContext()->GetSecurityOrigin());
   // FIXME: Set ForceOriginHeaderFlag.
   request->SetSameOriginDataURLFlag(true);
   request->SetReferrer(original->GetReferrer());
   request->SetMode(original->Mode());
   request->SetCredentials(original->Credentials());
+  request->SetCacheMode(original->CacheMode());
   request->SetAttachedCredential(original->AttachedCredential());
   request->SetRedirect(original->Redirect());
   request->SetIntegrity(original->Integrity());
-  // FIXME: Set cache mode.
-  // TODO(yhirano): Set redirect mode.
   return request;
 }
 
 Request* Request::CreateRequestWithRequestOrString(
     ScriptState* script_state,
     Request* input_request,
     const String& input_string,
     RequestInit& init,
     ExceptionState& exception_state) {
   // - "If |input| is a Request object and it is disturbed, throw a
@@ skipping 190 matching lines @@
       return nullptr;
     }
     request->SetCredentials(WebURLRequest::kFetchCredentialsModePassword);
     request->SetAttachedCredential(init.attached_credential);
     request->SetRedirect(WebURLRequest::kFetchRedirectModeManual);
   } else {
     if (!input_request)
       request->SetCredentials(WebURLRequest::kFetchCredentialsModeOmit);
   }
 
-  // TODO(yhirano): Implement the following step:
-  //   "If |init|'s cache member is present, set |request|'s cache mode to
-  //   it."
+  if (init.cache == "default") {
+    request->SetCacheMode(WebURLRequest::kFetchRequestCacheModeDefault);
+  } else if (init.cache == "no-store") {
+    request->SetCacheMode(WebURLRequest::kFetchRequestCacheModeNoStore);
+  } else if (init.cache == "reload") {
+    request->SetCacheMode(WebURLRequest::kFetchRequestCacheModeReload);
+  } else if (init.cache == "no-cache") {
+    request->SetCacheMode(WebURLRequest::kFetchRequestCacheModeNoCache);
+  } else if (init.cache == "force-cache") {
+    request->SetCacheMode(WebURLRequest::kFetchRequestCacheModeForceCache);
+  } else if (init.cache == "only-if-cached") {
+    request->SetCacheMode(WebURLRequest::kFetchRequestCacheModeOnlyIfCached);
+  }
 
-  // "If |init|'s redirect member is present, set |request|'s redirect mode
-  // to it."
   if (init.redirect == "follow") {
     request->SetRedirect(WebURLRequest::kFetchRedirectModeFollow);
   } else if (init.redirect == "error") {
     request->SetRedirect(WebURLRequest::kFetchRedirectModeError);
   } else if (init.redirect == "manual") {
     request->SetRedirect(WebURLRequest::kFetchRedirectModeManual);
   }
 
   // "If |init|'s integrity member is present, set |request|'s
   // integrity metadata to it."
@@ skipping 359 matching lines @@
       return "same-origin";
     case WebURLRequest::kFetchCredentialsModeInclude:
       return "include";
     case WebURLRequest::kFetchCredentialsModePassword:
       return "password";
   }
   ASSERT_NOT_REACHED();
   return "";
 }
 
+String Request::cache() const {
+  // "The cache attribute's getter must return request's cache mode."
+  switch (request_->CacheMode()) {
+    case WebURLRequest::kFetchRequestCacheModeDefault:
+      return "default";
+    case WebURLRequest::kFetchRequestCacheModeNoStore:
+      return "no-store";
+    case WebURLRequest::kFetchRequestCacheModeReload:
+      return "reload";
+    case WebURLRequest::kFetchRequestCacheModeNoCache:
+      return "no-cache";
+    case WebURLRequest::kFetchRequestCacheModeForceCache:
+      return "force-cache";
+    case WebURLRequest::kFetchRequestCacheModeOnlyIfCached:
+      return "only-if-cached";
+  }
+  NOTREACHED();
+  return "";
+}
+
 String Request::redirect() const {
   // "The redirect attribute's getter must return request's redirect mode."
   switch (request_->Redirect()) {
     case WebURLRequest::kFetchRedirectModeFollow:
       return "follow";
     case WebURLRequest::kFetchRedirectModeError:
       return "error";
     case WebURLRequest::kFetchRedirectModeManual:
       return "manual";
   }
@@ skipping 78 matching lines @@
       .Set(request.As<v8::Object>(), body_buffer);
 }
 
 DEFINE_TRACE(Request) {
   Body::Trace(visitor);
   visitor->Trace(request_);
   visitor->Trace(headers_);
 }
 
 }  // namespace blink