Reland of Move ScriptState::GetExecutionContext (Part 5)

third_party/WebKit/Source/modules/fetch/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 "modules/fetch/Response.h"
 
 #include <memory>
 #include "bindings/core/v8/Dictionary.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8ArrayBuffer.h"
 #include "bindings/core/v8/V8ArrayBufferView.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8Blob.h"
 #include "bindings/core/v8/V8FormData.h"
 #include "bindings/core/v8/V8PrivateProperty.h"
 #include "bindings/core/v8/V8URLSearchParams.h"
 #include "bindings/modules/v8/ByteStringSequenceSequenceOrByteStringByteStringRecordOrHeaders.h"
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/DOMArrayBufferView.h"
+#include "core/dom/ExecutionContext.h"
 #include "core/dom/URLSearchParams.h"
 #include "core/fileapi/Blob.h"
 #include "core/frame/UseCounter.h"
 #include "core/html/FormData.h"
 #include "core/streams/ReadableStreamOperations.h"
 #include "modules/fetch/BlobBytesConsumer.h"
 #include "modules/fetch/BodyStreamBuffer.h"
 #include "modules/fetch/FormDataBytesConsumer.h"
 #include "modules/fetch/ResponseInit.h"
 #include "platform/loader/fetch/FetchUtils.h"
@@ skipping 26 matching lines @@
   response->SetResponseTime(web_response.ResponseTime());
   response->SetCacheStorageCacheName(web_response.CacheStorageCacheName());
 
   for (HTTPHeaderMap::const_iterator i = web_response.Headers().begin(),
                                      end = web_response.Headers().end();
        i != end; ++i) {
     response->HeaderList()->Append(i->key, i->value);
   }
 
   response->ReplaceBodyStreamBuffer(new BodyStreamBuffer(
-      script_state, new BlobBytesConsumer(script_state->GetExecutionContext(),
+      script_state, new BlobBytesConsumer(ExecutionContext::From(script_state),
                                           web_response.GetBlobDataHandle())));
 
   // Filter the response according to |webResponse|'s ResponseType.
   switch (web_response.ResponseType()) {
     case kWebServiceWorkerResponseTypeBasic:
       response = response->CreateBasicFilteredResponse();
       break;
     case kWebServiceWorkerResponseTypeCORS: {
       HTTPHeaderSet header_names;
       for (const auto& header : web_response.CorsExposedHeaderNames())
@@ skipping 49 matching lines @@
   return Create(script_state, nullptr, String(), ResponseInit(),
                 exception_state);
 }
 
 Response* Response::Create(ScriptState* script_state,
                            ScriptValue body_value,
                            const ResponseInit& init,
                            ExceptionState& exception_state) {
   v8::Local<v8::Value> body = body_value.V8Value();
   v8::Isolate* isolate = script_state->GetIsolate();
-  ExecutionContext* execution_context = script_state->GetExecutionContext();
+  ExecutionContext* execution_context = ExecutionContext::From(script_state);
 
   BodyStreamBuffer* body_buffer = nullptr;
   String content_type;
   if (body_value.IsUndefined() || body_value.IsNull()) {
     // Note: The IDL processor cannot handle this situation. See
     // https://crbug.com/335871.
   } else if (V8Blob::hasInstance(body, isolate)) {
     Blob* blob = V8Blob::toImpl(body.As<v8::Object>());
     body_buffer = new BodyStreamBuffer(
         script_state,
@@ skipping 59 matching lines @@
 
   // "2. If |init|'s statusText member does not match the Reason-Phrase
   // token production, throw a TypeError."
   if (!IsValidReasonPhrase(init.statusText())) {
     exception_state.ThrowTypeError("Invalid statusText");
     return nullptr;
   }
 
   // "3. Let |r| be a new Response object, associated with a new response,
   // Headers object, and Body object."
-  Response* r = new Response(script_state->GetExecutionContext());
+  Response* r = new Response(ExecutionContext::From(script_state));
 
   // "4. Set |r|'s response's status to |init|'s status member."
   r->response_->SetStatus(init.status());
 
   // "5. Set |r|'s response's status message to |init|'s statusText member."
   r->response_->SetStatusMessage(AtomicString(init.statusText()));
 
   // "6. If |init|'s headers member is present, run these substeps:"
   if (init.hasHeaders()) {
     // "1. Empty |r|'s response's header list."
@@ skipping 48 matching lines @@
 
 Response* Response::Create(ExecutionContext* context,
                            FetchResponseData* response) {
   return new Response(context, response);
 }
 
 Response* Response::Create(ScriptState* script_state,
                            const WebServiceWorkerResponse& web_response) {
   FetchResponseData* response_data =
       CreateFetchResponseDataFromWebResponse(script_state, web_response);
-  return new Response(script_state->GetExecutionContext(), response_data);
+  return new Response(ExecutionContext::From(script_state), response_data);
 }
 
 Response* Response::error(ScriptState* script_state) {
   FetchResponseData* response_data =
       FetchResponseData::CreateNetworkErrorResponse();
   Response* r =
-      new Response(script_state->GetExecutionContext(), response_data);
+      new Response(ExecutionContext::From(script_state), response_data);
   r->headers_->SetGuard(Headers::kImmutableGuard);
   return r;
 }
 
 Response* Response::redirect(ScriptState* script_state,
                              const String& url,
                              unsigned short status,
                              ExceptionState& exception_state) {
-  KURL parsed_url = script_state->GetExecutionContext()->CompleteURL(url);
+  KURL parsed_url = ExecutionContext::From(script_state)->CompleteURL(url);
   if (!parsed_url.IsValid()) {
     exception_state.ThrowTypeError("Failed to parse URL from " + url);
     return nullptr;
   }
 
   if (!NetworkUtils::IsRedirectResponseCode(status)) {
     exception_state.ThrowRangeError("Invalid status code");
     return nullptr;
   }
 
-  Response* r = new Response(script_state->GetExecutionContext());
+  Response* r = new Response(ExecutionContext::From(script_state));
   r->headers_->SetGuard(Headers::kImmutableGuard);
   r->response_->SetStatus(status);
   r->response_->HeaderList()->Set("Location", parsed_url);
 
   return r;
 }
 
 String Response::type() const {
   // "The type attribute's getter must return response's type."
   switch (response_->GetType()) {
@@ skipping 138 matching lines @@
       .Set(response.As<v8::Object>(), body_buffer);
 }
 
 DEFINE_TRACE(Response) {
   Body::Trace(visitor);
   visitor->Trace(response_);
   visitor->Trace(headers_);
 }
 
 }  // namespace blink