[Web Payments] Implement the CVC Unmask dialog.

chrome/browser/ui/views/payments/payment_request_dialog_view.cc

 // 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 "chrome/browser/ui/views/payments/payment_request_dialog_view.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "chrome/browser/ui/views/payments/credit_card_editor_view_controller.h"
+#include "chrome/browser/ui/views/payments/cvc_unmask_view_controller.h"
 #include "chrome/browser/ui/views/payments/error_message_view_controller.h"
 #include "chrome/browser/ui/views/payments/order_summary_view_controller.h"
 #include "chrome/browser/ui/views/payments/payment_method_view_controller.h"
 #include "chrome/browser/ui/views/payments/payment_sheet_view_controller.h"
 #include "chrome/browser/ui/views/payments/profile_list_view_controller.h"
 #include "chrome/browser/ui/views/payments/shipping_address_editor_view_controller.h"
 #include "chrome/browser/ui/views/payments/shipping_option_view_controller.h"
 #include "components/constrained_window/constrained_window_views.h"
 #include "components/payments/content/payment_request.h"
 #include "content/public/browser/browser_thread.h"
 #include "ui/views/layout/fill_layout.h"
 
 namespace chrome {
 
 payments::PaymentRequestDialog* CreatePaymentRequestDialog(
     payments::PaymentRequest* request) {
   return new payments::PaymentRequestDialogView(request,
                                                 /* no observer */ nullptr);
 }
 
 }  // namespace chrome
 
 namespace payments {
+
+class CvcUnmaskUIDelegate

[Mathieu, 2017/03/30 14:37:32]

Can CvcUnmaskViewController be the
autofill::payments::FullCardRequest::UIDelegate ? This class doesn't do much but
forward the calls to the controller.

[anthonyvd, 2017/04/04 13:25:22]

The UIDelegate is now the CvcUnmaskViewController.

+    : public autofill::payments::FullCardRequest::UIDelegate,
+      public CvcUnmaskViewController::Observer {
+ public:
+  explicit CvcUnmaskUIDelegate(PaymentRequestDialogView* dialog,

[please use gerrit instead, 2017/03/30 13:14:09]

Explicit keyword is used only for constructors with a single parameter.

Add a comment that the parameters must outlive this object.

[anthonyvd, 2017/03/30 15:43:41]

Ah, there was a time when this only took one parameter :) Comment done.

+                               PaymentRequestSpec* spec,
+                               PaymentRequestState* state)
+      : dialog_(dialog), spec_(spec), state_(state), weak_ptr_factory_(this) {}
+
+  ~CvcUnmaskUIDelegate() override { OnClosed(); }
+
+  // autofill::payments::FullCardRequest::UIDelegate:
+  void ShowUnmaskPrompt(
+      const autofill::CreditCard& card,
+      autofill::AutofillClient::UnmaskCardReason reason,
+      base::WeakPtr<autofill::CardUnmaskDelegate> delegate) override {
+    unmask_delegate_ = delegate;
+    std::unique_ptr<CvcUnmaskViewController> view_controller =
+        base::MakeUnique<CvcUnmaskViewController>(
+            spec_, state_, dialog_, card.TypeAndLastFourDigits(), card.type());
+
+    view_controller->AddObserver(this);
+    dialog_->ShowCvcUnmaskSheet(std::move(view_controller));
+  }
+
+  void OnUnmaskVerificationResult(
+      autofill::AutofillClient::PaymentsRpcResult result) override {
+    // TODO(anthonyvd): Check result and display UI.
+  }
+
+  // CvcUnmaskViewController::Observer
+  void OnCvcConfirmed(const base::string16& cvc) override {
+    if (unmask_delegate_) {
+      autofill::CardUnmaskDelegate::UnmaskResponse response;
+      response.cvc = cvc;
+      unmask_delegate_->OnUnmaskResponse(response);
+    }
+  }
+
+  void OnClosed() override {
+    // TODO(anthonyvd): The dialog was closed, notify the full card request.
+  }
+
+  base::WeakPtr<CvcUnmaskUIDelegate> AsWeakPtr() {
+    return weak_ptr_factory_.GetWeakPtr();
+  }
+
+ private:
+  PaymentRequestDialogView* dialog_;
+  PaymentRequestSpec* spec_;
+  PaymentRequestState* state_;
+
+  base::WeakPtr<autofill::CardUnmaskDelegate> unmask_delegate_;
+
+  base::WeakPtrFactory<CvcUnmaskUIDelegate> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(CvcUnmaskUIDelegate);
+};
+
 namespace {
 
 // This function creates an instance of a PaymentRequestSheetController
 // subclass of concrete type |Controller|, passing it non-owned pointers to
 // |dialog| and the |request| that initiated that dialog. |map| should be owned
 // by |dialog|.
 std::unique_ptr<views::View> CreateViewAndInstallController(
     std::unique_ptr<PaymentRequestSheetController> controller,
     payments::ControllerMap* map) {
   std::unique_ptr<views::View> view = controller->CreateView();
@@ skipping 125 matching lines @@
 }
 
 void PaymentRequestDialogView::ShowShippingOptionSheet() {
   view_stack_.Push(CreateViewAndInstallController(
                        base::MakeUnique<ShippingOptionViewController>(
                            request_->spec(), request_->state(), this),
                        &controller_map_),
                    /* animate = */ true);
 }
 
+void PaymentRequestDialogView::ShowCvcUnmaskSheet(
+    std::unique_ptr<CvcUnmaskViewController> view_controller) {
+  view_stack_.Push(CreateViewAndInstallController(std::move(view_controller),
+                                                  &controller_map_),
+                   /* animate = */ true);
+}
+
 void PaymentRequestDialogView::ShowCreditCardEditor() {
   view_stack_.Push(CreateViewAndInstallController(
                        base::MakeUnique<CreditCardEditorViewController>(
                            request_->spec(), request_->state(), this),
                        &controller_map_),
                    /* animate = */ true);
   if (observer_for_testing_)
     observer_for_testing_->OnCreditCardEditorOpened();
 }
 
 void PaymentRequestDialogView::ShowShippingAddressEditor() {
   view_stack_.Push(CreateViewAndInstallController(
                        base::MakeUnique<ShippingAddressEditorViewController>(
                            request_->spec(), request_->state(), this),
                        &controller_map_),
                    /* animate = */ true);
   if (observer_for_testing_)
     observer_for_testing_->OnShippingAddressEditorOpened();
 }
 
 void PaymentRequestDialogView::EditorViewUpdated() {
   if (observer_for_testing_)
     observer_for_testing_->OnEditorViewUpdated();
 }
 
+base::WeakPtr<autofill::payments::FullCardRequest::UIDelegate>
+PaymentRequestDialogView::GetFullCardRequestUIDelegate() {
+  cvc_unmask_ui_delegate_ = base::MakeUnique<CvcUnmaskUIDelegate>(
+      this, request_->spec(), request_->state());
+  return cvc_unmask_ui_delegate_->AsWeakPtr();
+}
+
 void PaymentRequestDialogView::ShowInitialPaymentSheet() {
   view_stack_.Push(CreateViewAndInstallController(
                        base::MakeUnique<PaymentSheetViewController>(
                            request_->spec(), request_->state(), this),
                        &controller_map_),
                    /* animate = */ false);
   if (observer_for_testing_)
     observer_for_testing_->OnDialogOpened();
 }
 
 gfx::Size PaymentRequestDialogView::GetPreferredSize() const {
   return gfx::Size(450, 450);
 }
 
 void PaymentRequestDialogView::ViewHierarchyChanged(
     const ViewHierarchyChangedDetails& details) {
   if (being_closed_)
     return;
 
   // When a view that is associated with a controller is removed from this
   // view's descendants, dispose of the controller.
   if (!details.is_add &&
       controller_map_.find(details.child) != controller_map_.end()) {
     DCHECK(!details.move_view);
     controller_map_.erase(details.child);
   }
 }
 
 }  // namespace payments