Reland of Move ScriptState::GetExecutionContext (Part 5)

third_party/WebKit/Source/modules/credentialmanager/CredentialsContainer.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/credentialmanager/CredentialsContainer.h"
 
 #include <memory>
 #include "bindings/core/v8/Dictionary.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
@@ skipping 47 matching lines @@
     : public WebCredentialManagerClient::NotificationCallbacks {
   WTF_MAKE_NONCOPYABLE(NotificationCallbacks);
 
  public:
   explicit NotificationCallbacks(ScriptPromiseResolver* resolver)
       : resolver_(resolver) {}
   ~NotificationCallbacks() override {}
 
   void OnSuccess() override {
     Frame* frame =
-        ToDocument(resolver_->GetScriptState()->GetExecutionContext())
+        ToDocument(ExecutionContext::From(resolver_->GetScriptState()))
             ->GetFrame();
     SECURITY_CHECK(!frame || frame == frame->Tree().Top());
 
     resolver_->Resolve();
   }
 
   void OnError(WebCredentialManagerError reason) override {
     RejectDueToCredentialManagerError(resolver_, reason);
   }
 
  private:
   const Persistent<ScriptPromiseResolver> resolver_;
 };
 
 class RequestCallbacks : public WebCredentialManagerClient::RequestCallbacks {
   WTF_MAKE_NONCOPYABLE(RequestCallbacks);
 
  public:
   explicit RequestCallbacks(ScriptPromiseResolver* resolver)
       : resolver_(resolver) {}
   ~RequestCallbacks() override {}
 
   void OnSuccess(std::unique_ptr<WebCredential> web_credential) override {
     Frame* frame =
-        ToDocument(resolver_->GetScriptState()->GetExecutionContext())
+        ToDocument(ExecutionContext::From(resolver_->GetScriptState()))
             ->GetFrame();
     SECURITY_CHECK(!frame || frame == frame->Tree().Top());
 
     std::unique_ptr<WebCredential> credential =
         WTF::WrapUnique(web_credential.release());
     if (!credential || !frame) {
       resolver_->Resolve();
       return;
     }
 
     ASSERT(credential->IsPasswordCredential() ||
            credential->IsFederatedCredential());
-    UseCounter::Count(resolver_->GetScriptState()->GetExecutionContext(),
+    UseCounter::Count(ExecutionContext::From(resolver_->GetScriptState()),
                       UseCounter::kCredentialManagerGetReturnedCredential);
     if (credential->IsPasswordCredential())
       resolver_->Resolve(PasswordCredential::Create(
           static_cast<WebPasswordCredential*>(credential.get())));
     else
       resolver_->Resolve(FederatedCredential::Create(
           static_cast<WebFederatedCredential*>(credential.get())));
   }
 
   void OnError(WebCredentialManagerError reason) override {
     RejectDueToCredentialManagerError(resolver_, reason);
   }
 
  private:
   const Persistent<ScriptPromiseResolver> resolver_;
 };
 
 CredentialsContainer* CredentialsContainer::Create() {
   return new CredentialsContainer();
 }
 
 CredentialsContainer::CredentialsContainer() {}
 
 static bool CheckBoilerplate(ScriptPromiseResolver* resolver) {
-  Frame* frame =
-      ToDocument(resolver->GetScriptState()->GetExecutionContext())->GetFrame();
+  Frame* frame = ToDocument(ExecutionContext::From(resolver->GetScriptState()))
+                     ->GetFrame();
   if (!frame || frame != frame->Tree().Top()) {
     resolver->Reject(DOMException::Create(kSecurityError,
                                           "CredentialContainer methods may "
                                           "only be executed in a top-level "
                                           "document."));
     return false;
   }
 
   String error_message;
-  if (!resolver->GetScriptState()->GetExecutionContext()->IsSecureContext(
-          error_message)) {
+  if (!ExecutionContext::From(resolver->GetScriptState())
+           ->IsSecureContext(error_message)) {
     resolver->Reject(DOMException::Create(kSecurityError, error_message));
     return false;
   }
 
   CredentialManagerClient* client = CredentialManagerClient::From(
-      resolver->GetScriptState()->GetExecutionContext());
+      ExecutionContext::From(resolver->GetScriptState()));
   if (!client) {
     resolver->Reject(DOMException::Create(
         kInvalidStateError,
         "Could not establish connection to the credential manager."));
     return false;
   }
 
   return true;
 }
 
@@ skipping 14 matching lines @@
     // looping. In order to avoid this crazyness for the moment, we're making a
     // copy of the vector. https://crbug.com/587088
     const Vector<String> provider_strings = options.federated().providers();
     for (const auto& string : provider_strings) {
       KURL url = KURL(KURL(), string);
       if (url.IsValid())
         providers.push_back(url);
     }
   }
 
-  UseCounter::Count(script_state->GetExecutionContext(),
+  UseCounter::Count(ExecutionContext::From(script_state),
                     options.unmediated()
                         ? UseCounter::kCredentialManagerGetWithoutUI
                         : UseCounter::kCredentialManagerGetWithUI);
 
-  CredentialManagerClient::From(script_state->GetExecutionContext())
+  CredentialManagerClient::From(ExecutionContext::From(script_state))
       ->DispatchGet(options.unmediated(), options.password(), providers,
                     new RequestCallbacks(resolver));
   return promise;
 }
 
 ScriptPromise CredentialsContainer::store(ScriptState* script_state,
                                           Credential* credential) {
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
   ScriptPromise promise = resolver->Promise();
   if (!CheckBoilerplate(resolver))
     return promise;
 
   auto web_credential =
       WebCredential::Create(credential->GetPlatformCredential());
-  CredentialManagerClient::From(script_state->GetExecutionContext())
+  CredentialManagerClient::From(ExecutionContext::From(script_state))
       ->DispatchStore(*web_credential, new NotificationCallbacks(resolver));
   return promise;
 }
 
 ScriptPromise CredentialsContainer::requireUserMediation(
     ScriptState* script_state) {
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
   ScriptPromise promise = resolver->Promise();
   if (!CheckBoilerplate(resolver))
     return promise;
 
-  CredentialManagerClient::From(script_state->GetExecutionContext())
+  CredentialManagerClient::From(ExecutionContext::From(script_state))
       ->DispatchRequireUserMediation(new NotificationCallbacks(resolver));
   return promise;
 }
 
 }  // namespace blink