[Web Payments] Handle "Enter" accelerator when there's a primary action

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

 // Copyright 2017 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_sheet_controller.h"
 
 #include "chrome/browser/ui/views/payments/payment_request_dialog_view.h"
 #include "chrome/browser/ui/views/payments/payment_request_dialog_view_ids.h"
 #include "chrome/browser/ui/views/payments/payment_request_views_util.h"
 #include "components/payments/content/payment_request.h"
 #include "components/strings/grit/components_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/views/background.h"
 #include "ui/views/controls/button/md_text_button.h"
 #include "ui/views/controls/scroll_view.h"
 #include "ui/views/focus/focus_search.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/views/layout/fill_layout.h"
 #include "ui/views/layout/grid_layout.h"
 
 namespace payments {
 
 namespace {
 
+// This event is used to pass to ButtonPressed when its event parameter doesn't
+// matter, only the sender.
+class DummyEvent : public ui::Event {
+ public:
+  DummyEvent() : ui::Event(ui::ET_UNKNOWN, base::TimeTicks(), 0) {}
+};
+
 // This class is the actual sheet that gets pushed on the view_stack_. It
 // implements views::FocusTraversable to trap focus within its hierarchy. This
 // way, focus doesn't leave the topmost sheet on the view stack to go on views
 // that happen to be underneath.
 // This class also overrides RequestFocus() to allow consumers to specify which
 // view should be focused first (through SetFirstFocusableView). If no initial
 // view is specified, the first view added to the hierarchy will get focus when
 // this SheetView's RequestFocus() is called.
 class SheetView : public views::View, public views::FocusTraversable {
  public:
-  SheetView()
+  explicit SheetView(const base::Callback<bool()>& confirm_accelerator_callback)
       : first_focusable_(nullptr),
-        focus_search_(base::MakeUnique<views::FocusSearch>(this, true, false)) {
+        focus_search_(base::MakeUnique<views::FocusSearch>(this, true, false)),
+        confirm_accelerator_(ui::Accelerator(ui::VKEY_RETURN, ui::EF_NONE)),

[Mathieu, 2017/05/04 17:12:43]

nit: I would prefer |enter_key_accelerator|, because the fact that it confirms
is a choice of the caller.

[anthonyvd, 2017/05/04 18:56:46]

Done.

+        confirm_accelerator_callback_(confirm_accelerator_callback) {
+    if (confirm_accelerator_callback_)
+      AddAccelerator(confirm_accelerator_);
   }
 
   // Sets |view| as the first focusable view in this pane. If it's nullptr, the
   // fallback is to use focus_search_ to find the first focusable view.
   void SetFirstFocusableView(views::View* view) { first_focusable_ = view; }
 
  private:
   // views::FocusTraversable:
   views::FocusSearch* GetFocusSearch() override { return focus_search_.get(); }
 
@@ skipping 14 matching lines @@
       views::View* dummy_focus_traversable_view;
       first_focusable = focus_search_->FindNextFocusableView(
           nullptr, false, views::FocusSearch::DOWN, false,
           &dummy_focus_traversable, &dummy_focus_traversable_view);
     }
 
     if (first_focusable)
       first_focusable->RequestFocus();
   }
 
+  bool AcceleratorPressed(const ui::Accelerator& accelerator) override {
+    if (accelerator == confirm_accelerator_ && confirm_accelerator_callback_) {

[Mathieu, 2017/05/04 17:12:43]

no curlies?

[anthonyvd, 2017/05/04 18:56:46]

Since enter_key_accelerator is longer, the condition is now on 2 lines so the
curlies make this clearer.

+      return confirm_accelerator_callback_.Run();
+    }
+    return views::View::AcceleratorPressed(accelerator);
+  }
+
   views::View* first_focusable_;
   std::unique_ptr<views::FocusSearch> focus_search_;
+  ui::Accelerator confirm_accelerator_;
+  base::Callback<bool()> confirm_accelerator_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SheetView);
 };
 
 }  // namespace
 
 PaymentRequestSheetController::PaymentRequestSheetController(
     PaymentRequestSpec* spec,
     PaymentRequestState* state,
     PaymentRequestDialogView* dialog)
@@ skipping 48 matching lines @@
       dialog()->Pay();
       break;
     case PaymentRequestCommonTags::PAYMENT_REQUEST_COMMON_TAG_MAX:
       NOTREACHED();
       break;
   }
 }
 
 std::unique_ptr<views::View>
 PaymentRequestSheetController::CreatePaymentView() {
-  std::unique_ptr<SheetView> view = base::MakeUnique<SheetView>();
+  // Create the footer now so that it's known if there's a primary button or not
+  // before creating the sheet view. This way, it's possible to determine
+  // whether there's something to do when the user hits enter.
+  std::unique_ptr<views::View> footer = CreateFooterView();
+  std::unique_ptr<SheetView> view = base::MakeUnique<SheetView>(
+      primary_button_
+          ? base::Bind(
+                &PaymentRequestSheetController::PerformPrimaryButtonAction,
+                base::Unretained(this))
+          : base::Callback<bool()>());
   view->set_background(views::Background::CreateSolidBackground(SK_ColorWHITE));
 
   // Paint the sheets to layers, otherwise the MD buttons (which do paint to a
   // layer) won't do proper clipping.
   view->SetPaintToLayer();
 
   views::GridLayout* layout = new views::GridLayout(view.get());
   view->SetLayoutManager(layout);
 
   // Note: each view is responsible for its own padding (insets).
@@ skipping 26 matching lines @@
   pane_->SizeToPreferredSize();
 
   scroll_ = base::MakeUnique<views::ScrollView>();
   scroll_->set_owned_by_client();
   scroll_->EnableViewPortLayer();
   scroll_->set_hide_horizontal_scrollbar(true);
   scroll_->SetContents(pane_);
   layout->AddView(scroll_.get());
 
   layout->StartRow(0, 0);
-  layout->AddView(CreateFooterView().release());
+  layout->AddView(footer.release());
 
   view->SetFirstFocusableView(GetFirstFocusedView());
 
   return std::move(view);
 }
 
 std::unique_ptr<views::View> PaymentRequestSheetController::CreateFooterView() {
   std::unique_ptr<views::View> container = base::MakeUnique<views::View>();
 
   views::GridLayout* layout = new views::GridLayout(container.get());
@@ skipping 49 matching lines @@
 
 views::View* PaymentRequestSheetController::GetFirstFocusedView() {
   if (primary_button_ && primary_button_->enabled())
     return primary_button_.get();
 
   DCHECK(secondary_button_);
 
   return secondary_button_.get();
 }
 
+bool PaymentRequestSheetController::PerformPrimaryButtonAction() {
+  if (primary_button_ && primary_button_->enabled()) {
+    ButtonPressed(primary_button_.get(), DummyEvent());

[Mathieu, 2017/05/04 17:12:43]

could we inline ui::Event(ui::ET_UNKNOWN, base::TimeTicks(), 0) here?

[anthonyvd, 2017/05/04 18:56:46]

That constructor is protected.

+    return true;
+  }
+  return false;
+}
+
 }  // namespace payments