[Payment Request] Error message screen

ios/chrome/browser/payments/payment_request_manager.mm

 // 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.
 
 #import "ios/chrome/browser/payments/payment_request_manager.h"
 
+#include "base/ios/block_types.h"
 #include "base/ios/ios_util.h"
 #import "base/mac/bind_objc_block.h"
 #include "base/mac/foundation_util.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/sys_string_conversions.h"
 #import "base/values.h"
 #include "components/autofill/core/browser/autofill_manager.h"
 #include "components/autofill/core/browser/personal_data_manager.h"
 #include "components/autofill/ios/browser/autofill_driver_ios.h"
 #include "ios/chrome/browser/autofill/personal_data_manager_factory.h"
@@ skipping 43 matching lines @@
   // provided by the _personalDataManager and manages selected ones for the
   // current PaymentRequest flow.
   std::unique_ptr<PaymentRequest> _paymentRequest;
 
   // WebState for the tab this object is attached to.
   web::WebState* _webState;
 
   // Observer for |_webState|.
   std::unique_ptr<web::WebStateObserverBridge> _webStateObserver;
 
-  // Object that manages JavaScript injection into the web view.
-  __weak JSPaymentRequestManager* _paymentRequestJsManager;
-
   // Boolean to track if the current WebState is enabled (JS callback is set
   // up).
   BOOL _webStateEnabled;
 
   // Boolean to track if the script has been injected in the current page. This
   // is a faster check than asking the JS controller.
   BOOL _isScriptInjected;
 
   // True when close has been called and the PaymentRequest coordinator has
   // been destroyed.
   BOOL _closed;
 
   // Coordinator used to create and present the PaymentRequest view controller.
   PaymentRequestCoordinator* _paymentRequestCoordinator;
 
   // Timer used to periodically unblock the webview's JS event queue.
   NSTimer* _unblockEventQueueTimer;
 
-  // Timer used to close the UI if the page does not call
-  // PaymentResponse.complete() in a timely fashion.
+  // Timer used to complete the Payment Request flow and close the UI if the
+  // page does not call PaymentResponse.complete() in a timely fashion.
   NSTimer* _paymentResponseTimeoutTimer;
+
+  // Timer used to cancel the Payment Request flow and close the UI if the
+  // page does not settle the pending update promise in a timely fashion.
+  NSTimer* _updateEventTimeoutTimer;
 }
 
+// Object that manages JavaScript injection into the web view.
+@property(nonatomic, weak) JSPaymentRequestManager* paymentRequestJsManager;
+
 // Synchronous method executed by -asynchronouslyEnablePaymentRequest:
 - (void)doEnablePaymentRequest:(BOOL)enabled;
 
 // Initialize the PaymentRequest JavaScript.
 - (void)initializeWebViewForPaymentRequest;
 
 // Handler for injected JavaScript callbacks.
 - (BOOL)handleScriptCommand:(const base::DictionaryValue&)JSONCommand;
 
 // Handles invocations of PaymentRequest.show(). The value of the JavaScript
 // PaymentRequest object should be provided in |message|. Returns YES if the
 // invocation was successful.
 - (BOOL)handleRequestShow:(const base::DictionaryValue&)message;
 
+// Called by |_paymentResponseTimeoutTimer|, invokes handleResponseComplete:
+// as if PaymentResponse.complete() was invoked with the default "unknown"
+// argument.
+- (BOOL)handleResponseComplete;
+
 // Handles invocations of PaymentResponse.complete(). Returns YES if the
 // invocation was successful.
-- (BOOL)handleResponseComplete;
+- (BOOL)handleResponseComplete:(const base::DictionaryValue&)message;
 
 // Handles invocations of PaymentRequestUpdateEvent.updateWith(). Returns YES if
 // the invocation was successful.
 - (BOOL)handleUpdatePaymentDetails:(const base::DictionaryValue&)message;
 
 // Establishes a timer that periodically prompts the JS manager to execute a
 // noop. This works around an issue where the JS event queue is blocked while
 // presenting the Payment Request UI.
 - (void)setUnblockEventQueueTimer;
 
 // Establishes a timer that calls handleResponseComplete when it times out. Per
 // the spec, if the page does not call PaymentResponse.complete() within some
 // timeout period, user agents may behave as if the complete() method was
 // called with no arguments.
 - (void)setPaymentResponseTimeoutTimer;
 
+// Establishes a timer that dismisses the Payment Request UI when it times out.
+// Per the spec, implementations may choose to consider a timeout for the
+// promise provided with the PaymentRequestUpdateEvent.updateWith() call. If the
+// promise doesn't get settled in a reasonable amount of time, it is as if it
+// was rejected.
+- (void)setUpdateEventTimeoutTimer;
+
 @end
 
 @implementation PaymentRequestManager
 
 @synthesize enabled = _enabled;
 @synthesize webState = _webState;
 @synthesize browserState = _browserState;
+@synthesize paymentRequestJsManager = _paymentRequestJsManager;
 
 - (instancetype)initWithBaseViewController:(UIViewController*)viewController
                               browserState:
                                   (ios::ChromeBrowserState*)browserState {
   if ((self = [super init])) {
     _baseViewController = viewController;
 
     _browserState = browserState;
 
     _personalDataManager =
@@ skipping 122 matching lines @@
     return NO;
   }
 
   if (command == "paymentRequest.requestShow") {
     return [self handleRequestShow:JSONCommand];
   }
   if (command == "paymentRequest.requestCancel") {
     return [self handleRequestCancel];
   }
   if (command == "paymentRequest.responseComplete") {
-    return [self handleResponseComplete];
+    return [self handleResponseComplete:JSONCommand];
   }
   if (command == "paymentRequest.updatePaymentDetails") {
     return [self handleUpdatePaymentDetails:JSONCommand];
   }
   return NO;
 }
 
 - (BOOL)handleRequestShow:(const base::DictionaryValue&)message {
   // TODO(crbug.com/602666): check that there's not already a pending request.
   // TODO(crbug.com/602666): compare our supported payment types (i.e. autofill
@@ skipping 38 matching lines @@
   [_paymentRequestCoordinator start];
 
   return YES;
 }
 
 - (BOOL)handleRequestCancel {
   // TODO(crbug.com/602666): Check that there is already a pending request.
 
   [_unblockEventQueueTimer invalidate];
   [_paymentResponseTimeoutTimer invalidate];
+  [_updateEventTimeoutTimer invalidate];
 
-  [self cancelRequestWithErrorMessage:@"Request canceled by the page."];
+  __weak PaymentRequestManager* weakSelf = self;
+  ProceduralBlock callback = ^{
+    PaymentRequestManager* strongSelf = weakSelf;
+    // Early return if the manager has been deallocated.
+    if (!strongSelf)
+      return;
+    [strongSelf cancelRequestWithErrorMessage:@"Request canceled."];
+  };
+
+  [_paymentRequestCoordinator displayErrorWithCallback:callback];
 
   return YES;
 }
 
 - (BOOL)handleResponseComplete {
+  base::DictionaryValue command;
+  command.SetString("result", "unknown");
+  return [self handleResponseComplete:command];
+}
+
+- (BOOL)handleResponseComplete:(const base::DictionaryValue&)message {
   // TODO(crbug.com/602666): Check that there *is* a pending response here.
-  // TODO(crbug.com/602666): Indicate success or failure in the UI.
 
   [_unblockEventQueueTimer invalidate];
   [_paymentResponseTimeoutTimer invalidate];
+  [_updateEventTimeoutTimer invalidate];
 
-  [self dismissUI];
+  std::string result;
+  if (!message.GetString("result", &result)) {
+    DLOG(ERROR) << "JS message parameter 'result' is missing";
+    return NO;
+  }
 
-  [_paymentRequestJsManager resolveResponsePromiseWithCompletionHandler:nil];
+  __weak PaymentRequestManager* weakSelf = self;
+  ProceduralBlock callback = ^{
+    PaymentRequestManager* strongSelf = weakSelf;
+    // Early return if the manager has been deallocated.
+    if (!strongSelf)
+      return;
+    [strongSelf dismissUI];
+    [strongSelf.paymentRequestJsManager
+        resolveResponsePromiseWithCompletionHandler:nil];
+  };
+
+  // Display UI indicating failure if the value of |result| is "fail".
+  if (result == "fail") {
+    [_paymentRequestCoordinator displayErrorWithCallback:callback];
+  } else {
+    callback();
+  }
 
   return YES;
 }
 
 - (BOOL)handleUpdatePaymentDetails:(const base::DictionaryValue&)message {
   // TODO(crbug.com/602666): Check that there is already a pending request.
 
   [_unblockEventQueueTimer invalidate];
+  [_updateEventTimeoutTimer invalidate];
 
   const base::DictionaryValue* paymentDetailsData = nullptr;
   web::PaymentDetails paymentDetails;
   if (!message.GetDictionary("payment_details", &paymentDetailsData)) {
     DLOG(ERROR) << "JS message parameter 'payment_details' is missing";
     return NO;
   }
   if (!paymentDetails.FromDictionaryValue(*paymentDetailsData)) {
     DLOG(ERROR) << "JS message parameter 'payment_details' is invalid";
     return NO;
@@ skipping 15 matching lines @@
 
 - (void)setPaymentResponseTimeoutTimer {
   _paymentResponseTimeoutTimer =
       [NSTimer scheduledTimerWithTimeInterval:kTimeoutInterval
                                        target:self
                                      selector:@selector(handleResponseComplete)
                                      userInfo:nil
                                       repeats:NO];
 }
 
+- (void)setUpdateEventTimeoutTimer {
+  _updateEventTimeoutTimer =
+      [NSTimer scheduledTimerWithTimeInterval:kTimeoutInterval
+                                       target:self
+                                     selector:@selector(handleRequestCancel)
+                                     userInfo:nil
+                                      repeats:NO];
+}
+
 - (void)dismissUI {
   [_paymentRequestCoordinator stop];
   _paymentRequestCoordinator = nil;
 }
 
 - (BOOL)webStateContentIsSecureHTML {
   if (![self webState]) {
     return NO;
   }
 
   if (!web::UrlHasWebScheme([self webState]->GetLastCommittedURL()) ||
       ![self webState]->ContentIsHTML()) {
     return NO;
   }
 
   const web::NavigationItem* navigationItem =
       [self webState]->GetNavigationManager()->GetLastCommittedItem();
   return navigationItem &&
          navigationItem->GetSSL().security_style ==
              web::SECURITY_STYLE_AUTHENTICATED;
 }
 
 #pragma mark - PaymentRequestCoordinatorDelegate methods
 
 - (void)paymentRequestCoordinatorDidCancel:
     (PaymentRequestCoordinator*)coordinator {
-  [self cancelRequestWithErrorMessage:@"Request canceled by user."];
+  [self cancelRequestWithErrorMessage:@"Request canceled."];
 }
 
 - (void)paymentRequestCoordinator:(PaymentRequestCoordinator*)coordinator
     didConfirmWithPaymentResponse:(web::PaymentResponse)paymentResponse {
   [_paymentRequestJsManager
       resolveRequestPromiseWithPaymentResponse:paymentResponse
                              completionHandler:nil];
   [self setUnblockEventQueueTimer];
   [self setPaymentResponseTimeoutTimer];
 }
 
 - (void)paymentRequestCoordinator:(PaymentRequestCoordinator*)coordinator
          didSelectShippingAddress:(web::PaymentAddress)shippingAddress {
   [_paymentRequestJsManager updateShippingAddress:shippingAddress
                                 completionHandler:nil];
   [self setUnblockEventQueueTimer];
+  [self setUpdateEventTimeoutTimer];
 }
 
 - (void)paymentRequestCoordinator:(PaymentRequestCoordinator*)coordinator
           didSelectShippingOption:(web::PaymentShippingOption)shippingOption {
   [_paymentRequestJsManager updateShippingOption:shippingOption
                                completionHandler:nil];
   [self setUnblockEventQueueTimer];
+  [self setUpdateEventTimeoutTimer];
 }
 
 #pragma mark - CRWWebStateObserver methods
 
 - (void)webState:(web::WebState*)webState
     didCommitNavigationWithDetails:
         (const web::LoadCommittedDetails&)load_details {
   [self dismissUI];
   _isScriptInjected = NO;
   [self enableCurrentWebState];
   [self initializeWebViewForPaymentRequest];
 }
 
 @end