Reland of Move ScriptState::GetExecutionContext (Part 5)

third_party/WebKit/Source/modules/serviceworkers/FetchEvent.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/serviceworkers/FetchEvent.h"
 
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/ToV8ForCore.h"
 #include "bindings/core/v8/V8PrivateProperty.h"
+#include "core/dom/ExecutionContext.h"
 #include "modules/fetch/BytesConsumerForDataConsumerHandle.h"
 #include "modules/fetch/Request.h"
 #include "modules/fetch/Response.h"
 #include "modules/serviceworkers/FetchRespondWithObserver.h"
 #include "modules/serviceworkers/ServiceWorkerError.h"
 #include "modules/serviceworkers/ServiceWorkerGlobalScope.h"
 #include "platform/network/NetworkUtils.h"
 #include "platform/wtf/PtrUtil.h"
 #include "platform/wtf/RefPtr.h"
 #include "public/platform/WebURLResponse.h"
@@ skipping 48 matching lines @@
 
 FetchEvent::FetchEvent(ScriptState* script_state,
                        const AtomicString& type,
                        const FetchEventInit& initializer,
                        FetchRespondWithObserver* respond_with_observer,
                        WaitUntilObserver* wait_until_observer,
                        bool navigation_preload_sent)
     : ExtendableEvent(type, initializer, wait_until_observer),
       observer_(respond_with_observer),
       preload_response_property_(new PreloadResponseProperty(
-          script_state->GetExecutionContext(),
+          ExecutionContext::From(script_state),
           this,
           PreloadResponseProperty::kPreloadResponse)) {
   if (!navigation_preload_sent)
     preload_response_property_->ResolveWithUndefined();
 
   client_id_ = initializer.clientId();
   is_reload_ = initializer.isReload();
   if (initializer.hasRequest()) {
     ScriptState::Scope scope(script_state);
     request_ = initializer.request();
@@ skipping 22 matching lines @@
     std::unique_ptr<WebURLResponse> response,
     std::unique_ptr<WebDataConsumerHandle> data_consume_handle) {
   if (!script_state->ContextIsValid())
     return;
   DCHECK(preload_response_property_);
   ScriptState::Scope scope(script_state);
   FetchResponseData* response_data =
       data_consume_handle
           ? FetchResponseData::CreateWithBuffer(new BodyStreamBuffer(
                 script_state, new BytesConsumerForDataConsumerHandle(
-                                  script_state->GetExecutionContext(),
+                                  ExecutionContext::From(script_state),
                                   std::move(data_consume_handle))))
           : FetchResponseData::Create();
   Vector<KURL> url_list(1);
   url_list[0] = response->Url();
   response_data->SetURLList(url_list);
   response_data->SetStatus(response->HttpStatusCode());
   response_data->SetStatusMessage(response->HttpStatusText());
   response_data->SetResponseTime(response->ToResourceResponse().ResponseTime());
   const HTTPHeaderMap& headers(
       response->ToResourceResponse().HttpHeaderFields());
   for (const auto& header : headers) {
     response_data->HeaderList()->Append(header.key, header.value);
   }
   FetchResponseData* tainted_response =
       NetworkUtils::IsRedirectResponseCode(response->HttpStatusCode())
           ? response_data->CreateOpaqueRedirectFilteredResponse()
           : response_data->CreateBasicFilteredResponse();
   preload_response_property_->Resolve(
-      Response::Create(script_state->GetExecutionContext(), tainted_response));
+      Response::Create(ExecutionContext::From(script_state), tainted_response));
 }
 
 void FetchEvent::OnNavigationPreloadError(
     ScriptState* script_state,
     std::unique_ptr<WebServiceWorkerError> error) {
   if (!script_state->ContextIsValid())
     return;
   DCHECK(preload_response_property_);
   preload_response_property_->Reject(
       ServiceWorkerError::Take(nullptr, *error.get()));
 }
 
 DEFINE_TRACE(FetchEvent) {
   visitor->Trace(observer_);
   visitor->Trace(request_);
   visitor->Trace(preload_response_property_);
   ExtendableEvent::Trace(visitor);
 }
 
 }  // namespace blink