views - fade out more cvc prompt elements during verification process

chrome/browser/ui/views/autofill/card_unmask_prompt_views.cc

 // 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 "chrome/browser/ui/views/autofill/card_unmask_prompt_views.h"
 
 #include "base/basictypes.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/ui/autofill/autofill_dialog_types.h"
 #include "chrome/browser/ui/autofill/card_unmask_prompt_controller.h"
 #include "chrome/browser/ui/views/autofill/decorated_textfield.h"
 #include "chrome/browser/ui/views/autofill/tooltip_icon.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/constrained_window/constrained_window_views.h"
 #include "components/web_modal/web_contents_modal_dialog_host.h"
 #include "components/web_modal/web_contents_modal_dialog_manager.h"
 #include "components/web_modal/web_contents_modal_dialog_manager_delegate.h"
 #include "grit/theme_resources.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
+#include "ui/gfx/canvas.h"
 #include "ui/views/background.h"
 #include "ui/views/controls/button/checkbox.h"
 #include "ui/views/controls/combobox/combobox.h"
 #include "ui/views/controls/image_view.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/window/dialog_client_view.h"
 
 namespace autofill {
@@ skipping 12 matching lines @@
   CardUnmaskPromptViews* view = new CardUnmaskPromptViews(controller);
   view->Show();
   return view;
 }
 
 CardUnmaskPromptViews::CardUnmaskPromptViews(
     CardUnmaskPromptController* controller)
     : controller_(controller),
       main_contents_(nullptr),
       permanent_error_label_(nullptr),
+      input_row_(nullptr),
       cvc_input_(nullptr),
       month_input_(nullptr),
       year_input_(nullptr),
       error_label_(nullptr),
+      storage_row_(nullptr),
       storage_checkbox_(nullptr),
       progress_overlay_(nullptr),
       progress_label_(nullptr),
+      overlay_animation_(this),
       weak_ptr_factory_(this) {
 }
 
 CardUnmaskPromptViews::~CardUnmaskPromptViews() {
   if (controller_)
     controller_->OnUnmaskDialogClosed();
 }
 
 void CardUnmaskPromptViews::Show() {
   constrained_window::ShowWebModalDialogViews(this,
                                               controller_->GetWebContents());
 }
 
 void CardUnmaskPromptViews::ControllerGone() {
   controller_ = nullptr;
   ClosePrompt();
 }
 
 void CardUnmaskPromptViews::DisableAndWaitForVerification() {
   SetInputsEnabled(false);
+  progress_overlay_->SetOpacity(0.0);
   progress_overlay_->SetVisible(true);
+  overlay_animation_.Show();
   GetDialogClientView()->UpdateDialogButtons();
   Layout();
 }
 
 void CardUnmaskPromptViews::GotVerificationResult(
     const base::string16& error_message,
     bool allow_retry) {
   if (error_message.empty()) {
     progress_label_->SetText(l10n_util::GetStringUTF16(
         IDS_AUTOFILL_CARD_UNMASK_VERIFICATION_SUCCESS));
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE, base::Bind(&CardUnmaskPromptViews::ClosePrompt,
                               weak_ptr_factory_.GetWeakPtr()),
         controller_->GetSuccessMessageDuration());
   } else {
     // TODO(estade): it's somewhat jarring when the error comes back too
     // quickly.
+    overlay_animation_.Reset();
+    storage_row_->SetOpacity(1.0);
     progress_overlay_->SetVisible(false);
 
     if (allow_retry) {
       SetInputsEnabled(true);
 
       // If there is more than one input showing, don't mark anything as
       // invalid since we don't know the location of the problem.
       if (!controller_->ShouldRequestExpirationDate())
         cvc_input_->SetInvalid(true);
 
@@ skipping 40 matching lines @@
     year_input_->SetEnabled(enabled);
 }
 
 views::View* CardUnmaskPromptViews::GetContentsView() {
   InitIfNecessary();
   return this;
 }
 
 views::View* CardUnmaskPromptViews::CreateFootnoteView() {
   // Local storage checkbox and (?) tooltip.
-  views::View* storage_row = new views::View();
+  storage_row_ = new FadeOutView();
   views::BoxLayout* storage_row_layout = new views::BoxLayout(
       views::BoxLayout::kHorizontal, kEdgePadding, kEdgePadding, 0);
-  storage_row->SetLayoutManager(storage_row_layout);
-  storage_row->SetBorder(
+  storage_row_->SetLayoutManager(storage_row_layout);
+  storage_row_->SetBorder(
       views::Border::CreateSolidSidedBorder(1, 0, 0, 0, kSubtleBorderColor));
-  storage_row->set_background(
+  storage_row_->set_background(
       views::Background::CreateSolidBackground(kShadingColor));
 
   storage_checkbox_ = new views::Checkbox(l10n_util::GetStringUTF16(
       IDS_AUTOFILL_CARD_UNMASK_PROMPT_STORAGE_CHECKBOX));
   storage_checkbox_->SetChecked(controller_->GetStoreLocallyStartState());
-  storage_row->AddChildView(storage_checkbox_);
+  storage_row_->AddChildView(storage_checkbox_);
   storage_row_layout->SetFlexForView(storage_checkbox_, 1);
 
-  storage_row->AddChildView(new TooltipIcon(l10n_util::GetStringUTF16(
+  storage_row_->AddChildView(new TooltipIcon(l10n_util::GetStringUTF16(
       IDS_AUTOFILL_CARD_UNMASK_PROMPT_STORAGE_TOOLTIP)));
 
-  return storage_row;
+  return storage_row_;
 }
 
 gfx::Size CardUnmaskPromptViews::GetPreferredSize() const {
   // Must hardcode a width so the label knows where to wrap. TODO(estade):
   // This can lead to a weird looking dialog if we end up getting allocated
   // more width than we ask for, e.g. if the title is super long.
   const int kWidth = 375;
   return gfx::Size(kWidth, GetHeightForWidth(kWidth));
 }
 
 void CardUnmaskPromptViews::Layout() {
-  for (int i = 0; i < child_count(); ++i) {
-    child_at(i)->SetBoundsRect(GetContentsBounds());
-  }
+  gfx::Rect contents_bounds = GetContentsBounds();
+  main_contents_->SetBoundsRect(contents_bounds);
+
+  // The progress overlay extends from the top of the input row
+  // to the bottom of the content area.
+  gfx::RectF input_rect = input_row_->GetContentsBounds();
+  View::ConvertRectToTarget(input_row_, this, &input_rect);
+  input_rect.set_height(contents_bounds.height());
+  contents_bounds.Intersect(gfx::ToNearestRect(input_rect));
+  progress_overlay_->SetBoundsRect(contents_bounds);
 }
 
 int CardUnmaskPromptViews::GetHeightForWidth(int width) const {
   if (!has_children())
     return 0;
   const gfx::Insets insets = GetInsets();
   return main_contents_->GetHeightForWidth(width - insets.width()) +
          insets.height();
 }
 
 void CardUnmaskPromptViews::OnNativeThemeChanged(const ui::NativeTheme* theme) {
   SkColor bg_color =
       theme->GetSystemColor(ui::NativeTheme::kColorId_DialogBackground);
-  bg_color = SkColorSetA(bg_color, 0xDD);
   progress_overlay_->set_background(
       views::Background::CreateSolidBackground(bg_color));
 }
 
 ui::ModalType CardUnmaskPromptViews::GetModalType() const {
   return ui::MODAL_TYPE_CHILD;
 }
 
 base::string16 CardUnmaskPromptViews::GetWindowTitle() const {
   return controller_->GetWindowTitle();
@@ skipping 77 matching lines @@
     month_input_->SetInvalid(true);
     year_input_->SetInvalid(true);
     error_label_->SetMultiLine(true);
     SetRetriableErrorMessage(l10n_util::GetStringUTF16(
         IDS_AUTOFILL_CARD_UNMASK_INVALID_EXPIRATION_DATE));
   }
 
   GetDialogClientView()->UpdateDialogButtons();
 }
 
+void CardUnmaskPromptViews::AnimationProgressed(
+    const gfx::Animation* animation) {
+  progress_overlay_->SetOpacity(animation->GetCurrentValue());
+  storage_row_->SetOpacity(1.0 - animation->GetCurrentValue());
+}
+
 void CardUnmaskPromptViews::InitIfNecessary() {
   if (has_children())
     return;
 
   main_contents_ = new views::View();
   main_contents_->SetLayoutManager(
       new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 10));
   AddChildView(main_contents_);
 
   permanent_error_label_ = new views::Label();
@@ skipping 15 matching lines @@
   main_contents_->AddChildView(controls_container);
 
   views::Label* instructions =
       new views::Label(controller_->GetInstructionsMessage());
 
   instructions->SetMultiLine(true);
   instructions->SetHorizontalAlignment(gfx::ALIGN_LEFT);
   instructions->SetBorder(views::Border::CreateEmptyBorder(0, 0, 15, 0));
   controls_container->AddChildView(instructions);
 
-  views::View* input_row = new views::View();
-  input_row->SetLayoutManager(
+  input_row_ = new views::View();
+  input_row_->SetLayoutManager(
       new views::BoxLayout(views::BoxLayout::kHorizontal, 0, 0, 5));
-  controls_container->AddChildView(input_row);
+  controls_container->AddChildView(input_row_);
 
   if (controller_->ShouldRequestExpirationDate()) {
     month_input_ = new views::Combobox(&month_combobox_model_);
     month_input_->set_listener(this);
-    input_row->AddChildView(month_input_);
-    input_row->AddChildView(new views::Label(l10n_util::GetStringUTF16(
+    input_row_->AddChildView(month_input_);
+    input_row_->AddChildView(new views::Label(l10n_util::GetStringUTF16(
         IDS_AUTOFILL_CARD_UNMASK_EXPIRATION_DATE_SEPARATOR)));
     year_input_ = new views::Combobox(&year_combobox_model_);
     year_input_->set_listener(this);
-    input_row->AddChildView(year_input_);
-    input_row->AddChildView(new views::Label(base::ASCIIToUTF16("    ")));
+    input_row_->AddChildView(year_input_);
+    input_row_->AddChildView(new views::Label(base::ASCIIToUTF16("    ")));
   }
 
   cvc_input_ = new DecoratedTextfield(
       base::string16(),
       l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_PLACEHOLDER_CVC), this);
   cvc_input_->set_default_width_in_chars(8);
-  input_row->AddChildView(cvc_input_);
+  input_row_->AddChildView(cvc_input_);
 
   views::ImageView* cvc_image = new views::ImageView();
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   cvc_image->SetImage(rb.GetImageSkiaNamed(controller_->GetCvcImageRid()));
-  input_row->AddChildView(cvc_image);
+  input_row_->AddChildView(cvc_image);
 
   // Reserve vertical space for the error label, assuming it's one line.
   error_label_ = new views::Label(base::ASCIIToUTF16(" "));
   error_label_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
   error_label_->SetEnabledColor(kWarningColor);
   error_label_->SetBorder(views::Border::CreateEmptyBorder(3, 0, 5, 0));
   controls_container->AddChildView(error_label_);
 
-  progress_overlay_ = new views::View();
+  progress_overlay_ = new FadeOutView();
+  progress_overlay_->set_fade_everything(true);
   views::BoxLayout* progress_layout =
       new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 0);
   progress_layout->set_main_axis_alignment(
       views::BoxLayout::MAIN_AXIS_ALIGNMENT_CENTER);
   progress_layout->set_cross_axis_alignment(
       views::BoxLayout::CROSS_AXIS_ALIGNMENT_CENTER);
   progress_overlay_->SetLayoutManager(progress_layout);
 
   progress_overlay_->SetVisible(false);
   AddChildView(progress_overlay_);
 
   progress_label_ = new views::Label(l10n_util::GetStringUTF16(
       IDS_AUTOFILL_CARD_UNMASK_VERIFICATION_IN_PROGRESS));
   progress_overlay_->AddChildView(progress_label_);
 }
 
 bool CardUnmaskPromptViews::ExpirationDateIsValid() const {
   if (!controller_->ShouldRequestExpirationDate())
     return true;
 
   return controller_->InputExpirationIsValid(
       month_input_->GetTextForRow(month_input_->selected_index()),
       year_input_->GetTextForRow(year_input_->selected_index()));
 }
 
 void CardUnmaskPromptViews::ClosePrompt() {
   GetWidget()->Close();
 }
 
+CardUnmaskPromptViews::FadeOutView::FadeOutView()
+    : fade_everything_(false), opacity_(1.0) {
+}
+CardUnmaskPromptViews::FadeOutView::~FadeOutView() {
+}
+
+void CardUnmaskPromptViews::FadeOutView::PaintChildren(
+    gfx::Canvas* canvas,
+    const views::CullSet& cull_set) {
+  if (opacity_ > 0.99)
+    return views::View::PaintChildren(canvas, cull_set);
+
+  canvas->SaveLayerAlpha(0xff * opacity_);
+  views::View::PaintChildren(canvas, cull_set);
+  canvas->Restore();
+}
+
+void CardUnmaskPromptViews::FadeOutView::OnPaint(gfx::Canvas* canvas) {
+  if (!fade_everything_ || opacity_ > 0.99)
+    return views::View::OnPaint(canvas);
+
+  canvas->SaveLayerAlpha(0xff * opacity_);
+  views::View::OnPaint(canvas);
+  canvas->Restore();
+}
+
+void CardUnmaskPromptViews::FadeOutView::SetOpacity(double opacity) {
+  opacity_ = opacity;
+  SchedulePaint();
+}
+
 }  // namespace autofill