Reland of Move ScriptState::GetExecutionContext (Part 5)

third_party/WebKit/Source/modules/budget/BudgetService.cpp

 // Copyright 2016 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/budget/BudgetService.h"
 
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/ExceptionCode.h"
+#include "core/dom/ExecutionContext.h"
 #include "modules/budget/BudgetState.h"
 #include "public/platform/InterfaceProvider.h"
 #include "public/platform/Platform.h"
 #include "public/platform/modules/budget_service/budget_service.mojom-blink.h"
 
 namespace blink {
 namespace {
 
 mojom::blink::BudgetOperationType StringToOperationType(
     const AtomicString& operation) {
@@ skipping 31 matching lines @@
       WTF::Bind(&BudgetService::OnConnectionError, WrapWeakPersistent(this))));
 }
 
 BudgetService::~BudgetService() {}
 
 ScriptPromise BudgetService::getCost(ScriptState* script_state,
                                      const AtomicString& operation) {
   DCHECK(service_);
 
   String error_message;
-  if (!script_state->GetExecutionContext()->IsSecureContext(error_message))
+  if (!ExecutionContext::From(script_state)->IsSecureContext(error_message))
     return ScriptPromise::RejectWithDOMException(
         script_state, DOMException::Create(kSecurityError, error_message));
 
   mojom::blink::BudgetOperationType type = StringToOperationType(operation);
   DCHECK_NE(type, mojom::blink::BudgetOperationType::INVALID_OPERATION);
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
   ScriptPromise promise = resolver->Promise();
 
   // Get the cost for the action from the browser BudgetService.
   service_->GetCost(type, ConvertToBaseCallback(WTF::Bind(
                               &BudgetService::GotCost, WrapPersistent(this),
                               WrapPersistent(resolver))));
   return promise;
 }
 
 void BudgetService::GotCost(ScriptPromiseResolver* resolver,
                             double cost) const {
   resolver->Resolve(cost);
 }
 
 ScriptPromise BudgetService::getBudget(ScriptState* script_state) {
   DCHECK(service_);
 
   String error_message;
-  if (!script_state->GetExecutionContext()->IsSecureContext(error_message))
+  if (!ExecutionContext::From(script_state)->IsSecureContext(error_message))
     return ScriptPromise::RejectWithDOMException(
         script_state, DOMException::Create(kSecurityError, error_message));
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
   ScriptPromise promise = resolver->Promise();
 
   // Get the budget from the browser BudgetService.
   RefPtr<SecurityOrigin> origin(
-      script_state->GetExecutionContext()->GetSecurityOrigin());
+      ExecutionContext::From(script_state)->GetSecurityOrigin());
   service_->GetBudget(
       origin, ConvertToBaseCallback(WTF::Bind(&BudgetService::GotBudget,
                                               WrapPersistent(this),
                                               WrapPersistent(resolver))));
   return promise;
 }
 
 void BudgetService::GotBudget(
     ScriptPromiseResolver* resolver,
     mojom::blink::BudgetServiceErrorType error,
@@ skipping 16 matching lines @@
 }
 
 ScriptPromise BudgetService::reserve(ScriptState* script_state,
                                      const AtomicString& operation) {
   DCHECK(service_);
 
   mojom::blink::BudgetOperationType type = StringToOperationType(operation);
   DCHECK_NE(type, mojom::blink::BudgetOperationType::INVALID_OPERATION);
 
   String error_message;
-  if (!script_state->GetExecutionContext()->IsSecureContext(error_message))
+  if (!ExecutionContext::From(script_state)->IsSecureContext(error_message))
     return ScriptPromise::RejectWithDOMException(
         script_state, DOMException::Create(kSecurityError, error_message));
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
   ScriptPromise promise = resolver->Promise();
 
   // Call to the BudgetService to place the reservation.
   RefPtr<SecurityOrigin> origin(
-      script_state->GetExecutionContext()->GetSecurityOrigin());
+      ExecutionContext::From(script_state)->GetSecurityOrigin());
   service_->Reserve(origin, type,
                     ConvertToBaseCallback(WTF::Bind(
                         &BudgetService::GotReservation, WrapPersistent(this),
                         WrapPersistent(resolver))));
   return promise;
 }
 
 void BudgetService::GotReservation(ScriptPromiseResolver* resolver,
                                    mojom::blink::BudgetServiceErrorType error,
                                    bool success) const {
   if (error != mojom::blink::BudgetServiceErrorType::NONE) {
     resolver->Reject(ErrorTypeToException(error));
     return;
   }
 
   resolver->Resolve(success);
 }
 
 void BudgetService::OnConnectionError() {
   LOG(ERROR) << "Unable to connect to the Mojo BudgetService.";
   // TODO(harkness): Reject in flight promises.
 }
 
 }  // namespace blink