Rename canMakeActivePayment to canMakePayment

third_party/WebKit/Source/modules/payments/PaymentRequest.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/payments/PaymentRequest.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8StringResource.h"
@@ skipping 20 matching lines @@
 #include "mojo/public/cpp/bindings/wtf_array.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/mojo/MojoHelper.h"
 #include "public/platform/InterfaceProvider.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebTraceLocation.h"
 #include "wtf/HashSet.h"
 #include <stddef.h>
 #include <utility>
 
-using payments::mojom::blink::ActivePaymentQueryResult;
+using payments::mojom::blink::CanMakePaymentQueryResult;
 using payments::mojom::blink::PaymentAddressPtr;
 using payments::mojom::blink::PaymentCurrencyAmount;
 using payments::mojom::blink::PaymentCurrencyAmountPtr;
 using payments::mojom::blink::PaymentDetailsModifierPtr;
 using payments::mojom::blink::PaymentDetailsPtr;
 using payments::mojom::blink::PaymentErrorReason;
 using payments::mojom::blink::PaymentItemPtr;
 using payments::mojom::blink::PaymentMethodDataPtr;
 using payments::mojom::blink::PaymentOptionsPtr;
 using payments::mojom::blink::PaymentResponsePtr;
@@ skipping 493 matching lines @@
     return ScriptPromise::rejectWithDOMException(
         scriptState,
         DOMException::create(InvalidStateError,
                              "Never called show(), so nothing to abort"));
 
   m_abortResolver = ScriptPromiseResolver::create(scriptState);
   m_paymentProvider->Abort();
   return m_abortResolver->promise();
 }
 
-ScriptPromise PaymentRequest::canMakeActivePayment(ScriptState* scriptState) {
-  if (!m_paymentProvider.is_bound() || m_canMakeActivePaymentResolver ||
+ScriptPromise PaymentRequest::canMakePayment(ScriptState* scriptState) {
+  if (!m_paymentProvider.is_bound() || m_canMakePaymentResolver ||
       !scriptState->contextIsValid()) {
     return ScriptPromise::rejectWithDOMException(
         scriptState, DOMException::create(InvalidStateError,
                                           "Cannot query payment request"));
   }
 
-  m_paymentProvider->CanMakeActivePayment();
+  m_paymentProvider->CanMakePayment();
 
-  m_canMakeActivePaymentResolver = ScriptPromiseResolver::create(scriptState);
-  return m_canMakeActivePaymentResolver->promise();
+  m_canMakePaymentResolver = ScriptPromiseResolver::create(scriptState);
+  return m_canMakePaymentResolver->promise();
 }
 
 bool PaymentRequest::hasPendingActivity() const {
   return m_showResolver || m_completeResolver;
 }
 
 const AtomicString& PaymentRequest::interfaceName() const {
   return EventTargetNames::PaymentRequest;
 }
 
@@ skipping 69 matching lines @@
     m_completeResolver->reject(DOMException::create(AbortError, error));
   clearResolversAndCloseMojoConnection();
 }
 
 DEFINE_TRACE(PaymentRequest) {
   visitor->trace(m_options);
   visitor->trace(m_shippingAddress);
   visitor->trace(m_showResolver);
   visitor->trace(m_completeResolver);
   visitor->trace(m_abortResolver);
-  visitor->trace(m_canMakeActivePaymentResolver);
+  visitor->trace(m_canMakePaymentResolver);
   EventTargetWithInlineData::trace(visitor);
   ContextLifecycleObserver::trace(visitor);
 }
 
 void PaymentRequest::onCompleteTimeoutForTesting() {
   m_completeTimer.stop();
   onCompleteTimeout(0);
 }
 
 PaymentRequest::PaymentRequest(Document& document,
@@ skipping 173 matching lines @@
   if (isError) {
     if (m_completeResolver)
       m_completeResolver->reject(DOMException::create(ec, message));
 
     if (m_showResolver)
       m_showResolver->reject(DOMException::create(ec, message));
 
     if (m_abortResolver)
       m_abortResolver->reject(DOMException::create(ec, message));
 
-    if (m_canMakeActivePaymentResolver)
-      m_canMakeActivePaymentResolver->reject(DOMException::create(ec, message));
+    if (m_canMakePaymentResolver)
+      m_canMakePaymentResolver->reject(DOMException::create(ec, message));
   } else {
     if (m_completeResolver)
       m_completeResolver->reject(message);
 
     if (m_showResolver)
       m_showResolver->reject(message);
 
     if (m_abortResolver)
       m_abortResolver->reject(message);
 
-    if (m_canMakeActivePaymentResolver)
-      m_canMakeActivePaymentResolver->reject(message);
+    if (m_canMakePaymentResolver)
+      m_canMakePaymentResolver->reject(message);
   }
 
   clearResolversAndCloseMojoConnection();
 }
 
 void PaymentRequest::OnComplete() {
   DCHECK(m_completeResolver);
   m_completeResolver->resolve();
   clearResolversAndCloseMojoConnection();
 }
 
 void PaymentRequest::OnAbort(bool abortedSuccessfully) {
   DCHECK(m_abortResolver);
   DCHECK(m_showResolver);
 
   if (!abortedSuccessfully) {
     m_abortResolver->reject(DOMException::create(InvalidStateError));
     m_abortResolver.clear();
     return;
   }
 
   m_showResolver->reject(DOMException::create(AbortError));
   m_abortResolver->resolve();
   clearResolversAndCloseMojoConnection();
 }
 
-void PaymentRequest::OnCanMakeActivePayment(ActivePaymentQueryResult result) {
-  DCHECK(m_canMakeActivePaymentResolver);
+void PaymentRequest::OnCanMakePayment(CanMakePaymentQueryResult result) {
+  DCHECK(m_canMakePaymentResolver);
 
   switch (result) {
-    case ActivePaymentQueryResult::CAN_MAKE_ACTIVE_PAYMENT:
-      m_canMakeActivePaymentResolver->resolve(true);
+    case CanMakePaymentQueryResult::CAN_MAKE_PAYMENT:
+      m_canMakePaymentResolver->resolve(true);
       break;
-    case ActivePaymentQueryResult::CANNOT_MAKE_ACTIVE_PAYMENT:
-      m_canMakeActivePaymentResolver->resolve(false);
+    case CanMakePaymentQueryResult::CANNOT_MAKE_PAYMENT:
+      m_canMakePaymentResolver->resolve(false);
       break;
-    case ActivePaymentQueryResult::QUERY_QUOTA_EXCEEDED:
-      m_canMakeActivePaymentResolver->reject(
+    case CanMakePaymentQueryResult::QUERY_QUOTA_EXCEEDED:
+      m_canMakePaymentResolver->reject(
           DOMException::create(QuotaExceededError, "Query quota exceeded"));
       break;
   }
 
-  m_canMakeActivePaymentResolver.clear();
+  m_canMakePaymentResolver.clear();
 }
 
 void PaymentRequest::onCompleteTimeout(TimerBase*) {
   m_paymentProvider->Complete(payments::mojom::blink::PaymentComplete(Fail));
   clearResolversAndCloseMojoConnection();
 }
 
 void PaymentRequest::clearResolversAndCloseMojoConnection() {
   m_completeTimer.stop();
   m_completeResolver.clear();
   m_showResolver.clear();
   m_abortResolver.clear();
-  m_canMakeActivePaymentResolver.clear();
+  m_canMakePaymentResolver.clear();
   if (m_clientBinding.is_bound())
     m_clientBinding.Close();
   m_paymentProvider.reset();
 }
 
 }  // namespace blink