Move ScriptState::GetExecutionContext (Part 5)

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 17 matching lines @@
 FetchRequestData* CreateCopyOfFetchRequestDataForFetch(
     ScriptState* script_state,
     const FetchRequestData* original) {
   FetchRequestData* request = FetchRequestData::Create();
   request->SetURL(original->Url());
   request->SetMethod(original->Method());
   request->SetHeaderList(original->HeaderList()->Clone());
   request->SetUnsafeRequestFlag(true);
   // FIXME: Set client.
   DOMWrapperWorld& world = script_state->World();
-  if (world.IsIsolatedWorld())
+  if (world.IsIsolatedWorld()) {
     request->SetOrigin(world.IsolatedWorldSecurityOrigin());
-  else
+  } else {
     request->SetOrigin(
-        script_state->GetExecutionContext()->GetSecurityOrigin());
+        ExecutionContext::From(script_state)->GetSecurityOrigin());
+  }
   // FIXME: Set ForceOriginHeaderFlag.
   request->SetSameOriginDataURLFlag(true);
   request->SetReferrer(original->GetReferrer());
   request->SetMode(original->Mode());
   request->SetCredentials(original->Credentials());
   request->SetAttachedCredential(original->AttachedCredential());
   request->SetRedirect(original->Redirect());
   request->SetIntegrity(original->Integrity());
   // FIXME: Set cache mode.
   // TODO(yhirano): Set redirect mode.
@@ skipping 16 matching lines @@
   }
   // - "Let |temporaryBody| be |input|'s request's body if |input| is a
   //   Request object, and null otherwise."
   BodyStreamBuffer* temporary_body =
       input_request ? input_request->BodyBuffer() : nullptr;
 
   // "Let |request| be |input|'s request, if |input| is a Request object,
   // and a new request otherwise."
 
   RefPtr<SecurityOrigin> origin =
-      script_state->GetExecutionContext()->GetSecurityOrigin();
+      ExecutionContext::From(script_state)->GetSecurityOrigin();
 
   // TODO(yhirano): Implement the following steps:
   // - "Let |window| be client."
   // - "If |request|'s window is an environment settings object and its
   //   origin is same origin with entry settings object's origin, set
   //   |window| to |request|'s window."
   // - "If |init|'s window member is present and it is not null, throw a
   //   TypeError."
   // - "If |init|'s window member is present, set |window| to no-window."
   //
@@ skipping 13 matching lines @@
 
   // We don't use fallback values. We set these flags directly in below.
   // - "Let |fallbackMode| be null."
   // - "Let |fallbackCredentials| be null."
   // - "Let |baseURL| be entry settings object's API base URL."
 
   // "If |input| is a string, run these substeps:"
   if (!input_request) {
     // "Let |parsedURL| be the result of parsing |input| with |baseURL|."
     KURL parsed_url =
-        script_state->GetExecutionContext()->CompleteURL(input_string);
+        ExecutionContext::From(script_state)->CompleteURL(input_string);
     // "If |parsedURL| is failure, throw a TypeError."
     if (!parsed_url.IsValid()) {
       exception_state.ThrowTypeError("Failed to parse URL from " +
                                      input_string);
       return nullptr;
     }
     //   "If |parsedURL| includes credentials, throw a TypeError."
     if (!parsed_url.User().IsEmpty() || !parsed_url.Pass().IsEmpty()) {
       exception_state.ThrowTypeError(
           "Request cannot be constructed from a URL that includes "
@@ skipping 48 matching lines @@
     // Nothing to do for the step "Let |referrer| be |init|'s referrer
     // member."
 
     if (init.referrer.referrer.IsEmpty()) {
       // "If |referrer| is the empty string, set |request|'s referrer to
       // "no-referrer" and terminate these substeps."
       request->SetReferrerString(AtomicString(Referrer::NoReferrer()));
     } else {
       // "Let |parsedReferrer| be the result of parsing |referrer| with
       // |baseURL|."
-      KURL parsed_referrer = script_state->GetExecutionContext()->CompleteURL(
-          init.referrer.referrer);
+      KURL parsed_referrer = ExecutionContext::From(script_state)
+                                 ->CompleteURL(init.referrer.referrer);
       if (!parsed_referrer.IsValid()) {
         // "If |parsedReferrer| is failure, throw a TypeError."
         exception_state.ThrowTypeError("Referrer '" + init.referrer.referrer +
                                        "' is not a valid URL.");
         return nullptr;
       }
       if (parsed_referrer.ProtocolIsAbout() &&
           parsed_referrer.Host().IsEmpty() &&
           parsed_referrer.GetPath() == "client") {
         // "If |parsedReferrer|'s non-relative flag is set, scheme is
@@ skipping 241 matching lines @@
 Request* Request::Create(ScriptState* script_state,
                          const String& input,
                          ExceptionState& exception_state) {
   return Create(script_state, input, Dictionary(), exception_state);
 }
 
 Request* Request::Create(ScriptState* script_state,
                          const String& input,
                          const Dictionary& init,
                          ExceptionState& exception_state) {
-  RequestInit request_init(script_state->GetExecutionContext(), init,
+  RequestInit request_init(ExecutionContext::From(script_state), init,
                            exception_state);
   return CreateRequestWithRequestOrString(script_state, nullptr, input,
                                           request_init, exception_state);
 }
 
 Request* Request::Create(ScriptState* script_state,
                          Request* input,
                          ExceptionState& exception_state) {
   return Create(script_state, input, Dictionary(), exception_state);
 }
 
 Request* Request::Create(ScriptState* script_state,
                          Request* input,
                          const Dictionary& init,
                          ExceptionState& exception_state) {
-  RequestInit request_init(script_state->GetExecutionContext(), init,
+  RequestInit request_init(ExecutionContext::From(script_state), init,
                            exception_state);
   return CreateRequestWithRequestOrString(script_state, input, String(),
                                           request_init, exception_state);
 }
 
 Request* Request::Create(ScriptState* script_state, FetchRequestData* request) {
   return new Request(script_state, request);
 }
 
 Request* Request::Create(ScriptState* script_state,
                          const WebServiceWorkerRequest& web_request) {
   FetchRequestData* request =
       FetchRequestData::Create(script_state, web_request);
   return new Request(script_state, request);
 }
 
 Request::Request(ScriptState* script_state,
                  FetchRequestData* request,
                  Headers* headers)
-    : Body(script_state->GetExecutionContext()),
+    : Body(ExecutionContext::From(script_state)),
       request_(request),
       headers_(headers) {
   RefreshBody(script_state);
 }
 
 Request::Request(ScriptState* script_state, FetchRequestData* request)
     : Request(script_state, request, Headers::Create(request->HeaderList())) {
   headers_->SetGuard(Headers::kRequestGuard);
 }
 
@@ skipping 241 matching lines @@
       .Set(request.As<v8::Object>(), body_buffer);
 }
 
 DEFINE_TRACE(Request) {
   Body::Trace(visitor);
   visitor->Trace(request_);
   visitor->Trace(headers_);
 }
 
 }  // namespace blink