Edit button makes username editable in the password manager bubble.

chrome/browser/ui/views/passwords/manage_password_items_view.cc

 // Copyright 2013 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/passwords/manage_password_items_view.h"
 
 #include <numeric>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/ui/passwords/manage_passwords_bubble_model.h"
 #include "chrome/browser/ui/passwords/manage_passwords_view_utils.h"
 #include "chrome/browser/ui/views/harmony/chrome_layout_provider.h"
 #include "chrome/browser/ui/views/harmony/chrome_typography.h"
+#include "chrome/browser/ui/views/passwords/manage_passwords_bubble_view.h"

[vasilii, 2017/06/30 15:28:05]

Remove

[irmakk, 2017/07/03 14:56:53]

Done.

 #include "chrome/grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/resources/grit/ui_resources.h"
 #include "ui/views/controls/button/button.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/controls/link.h"
 #include "ui/views/controls/link_listener.h"
+#include "ui/views/controls/textfield/textfield.h"
 #include "ui/views/layout/fill_layout.h"
 #include "ui/views/layout/grid_layout.h"
 
 namespace {
 
 enum ColumnSets {
   ONE_COLUMN_SET,
   TWO_COLUMN_SET,
   THREE_COLUMN_SET
 };
@@ skipping 36 matching lines @@
 }
 
 std::unique_ptr<views::Label> GenerateUsernameLabel(
     const autofill::PasswordForm& form) {
   auto label = base::MakeUnique<views::Label>(GetDisplayUsername(form),
                                               CONTEXT_DEPRECATED_SMALL);
   label->SetHorizontalAlignment(gfx::ALIGN_LEFT);
   return label;
 }
 
+std::unique_ptr<views::Textfield> GenerateUsernameEditable(
+    const ::autofill::PasswordForm& form) {

[vasilii, 2017/06/30 15:28:06]

While it's totally correct, we should be consistent in the file. Thus, ::
everywhere for PasswordForm or never. I prefer the latter :)

[irmakk, 2017/07/03 14:56:54]

Done.

+  auto editable = base::MakeUnique<views::Textfield>();
+  editable->SetText(GetDisplayUsername(form));
+  editable->SetHorizontalAlignment(gfx::ALIGN_LEFT);

[vasilii, 2017/06/30 15:28:05]

I'm pretty sure that by default views::Textfield does the right thing. This
line, however, handles the RTL languages wrong.

Just remove it.

[irmakk, 2017/07/03 14:56:53]

Removing.
But please see line #79, the username label sets its alignment to left also, do
you think this inconsistency will cause any problems?

[vasilii, 2017/07/03 17:15:30]

Label::SetHorizontalAlignment swaps it for RTL

+  return editable;
+}
+
 std::unique_ptr<views::Label> GeneratePasswordLabel(
     const autofill::PasswordForm& form) {
   base::string16 text =
       form.federation_origin.unique()
           ? form.password_value
           : l10n_util::GetStringFUTF16(
                 IDS_PASSWORDS_VIA_FEDERATION,
                 base::UTF8ToUTF16(form.federation_origin.host()));
   auto label = base::MakeUnique<views::Label>(text, CONTEXT_DEPRECATED_SMALL);
   label->SetHorizontalAlignment(gfx::ALIGN_LEFT);
@@ skipping 34 matching lines @@
   undo_link->SetUnderline(false);
   undo_link->SetFontList(views::style::GetFont(CONTEXT_DEPRECATED_SMALL,
                                                views::style::STYLE_LINK));
   return undo_link;
 }
 
 }  // namespace
 
 // Manage credentials: stores credentials state and adds proper row to layout
 // based on credential state.
-class ManagePasswordItemsView::PasswordFormRow : public views::ButtonListener,
-                                                 public views::LinkListener {
+class ManagePasswordItemsView::PasswordFormRow
+    : public views::ButtonListener,
+      public views::LinkListener,
+      public views::FocusChangeListener {
  public:
   PasswordFormRow(ManagePasswordItemsView* host,
                   const autofill::PasswordForm* password_form,
                   int fixed_height);
   ~PasswordFormRow() override = default;
 
   void AddRow(views::GridLayout* layout);
+  RowStatus row_status_;

[vasilii, 2017/06/30 15:28:06]

Should be private

 
   // Returns the fixed height for a row excluding padding. 0 means no fixed
   // height required.
   // In MANAGE_STATE a row may represent a credential or a deleted credential.
   // To avoid repositioning all the rows should have a fixed height.
   static int GetFixedHeight(password_manager::ui::State state);
 
  private:
   void AddCredentialsRow(views::GridLayout* layout);
   void AddUndoRow(views::GridLayout* layout);
 
   // views::ButtonListener:
   void ButtonPressed(views::Button* sender, const ui::Event& event) override;
   // views::LinkListener:
   void LinkClicked(views::Link* source, int event_flags) override;
+  // views::FocusChangeListener:
+  void OnWillChangeFocus(View* focused_before, View* focused_now) override;
+  void OnDidChangeFocus(View* focused_before, View* focused_now) override;
 
   void ResetControls();
 
   ManagePasswordItemsView* host_;
   const autofill::PasswordForm* password_form_;
   // The UI elements pointers are weak and owned by their parent.
   views::Link* undo_link_;
   views::ImageButton* delete_button_;
   const int fixed_height_;
-  bool deleted_;
+  views::Textfield* editable_;
 
   DISALLOW_COPY_AND_ASSIGN(PasswordFormRow);
 };
 
 ManagePasswordItemsView::PasswordFormRow::PasswordFormRow(
     ManagePasswordItemsView* host,
     const autofill::PasswordForm* password_form,
     int fixed_height)
-    : host_(host),
+    : row_status_(RowStatus::DEFAULT),
+      host_(host),
       password_form_(password_form),
       undo_link_(nullptr),
       delete_button_(nullptr),
       fixed_height_(fixed_height),
-      deleted_(false) {}
+      editable_(nullptr) {}
 
 void ManagePasswordItemsView::PasswordFormRow::AddRow(
     views::GridLayout* layout) {
-  if (deleted_) {
+  if (row_status_ == RowStatus::DELETED) {
     AddUndoRow(layout);
   } else {
     AddCredentialsRow(layout);
   }
 }
 
 int ManagePasswordItemsView::PasswordFormRow::GetFixedHeight(
     password_manager::ui::State state) {
   if (state != password_manager::ui::MANAGE_STATE)
     return 0;
@@ skipping 10 matching lines @@
 
 void ManagePasswordItemsView::PasswordFormRow::AddCredentialsRow(
     views::GridLayout* layout) {
   ResetControls();
   int column_set_id =
       host_->model_->state() == password_manager::ui::MANAGE_STATE
           ? THREE_COLUMN_SET
           : TWO_COLUMN_SET;
   BuildColumnSetIfNeeded(layout, column_set_id);
   layout->StartRow(0, column_set_id);
-  layout->AddView(GenerateUsernameLabel(*password_form_).release(), 1, 1,
-                  views::GridLayout::FILL, views::GridLayout::FILL,
-                  0, fixed_height_);
+  if (row_status_ == RowStatus::DEFAULT) {
+    layout->AddView(GenerateUsernameLabel(*password_form_).release(), 1, 1,
+                    views::GridLayout::FILL, views::GridLayout::FILL, 0,
+                    fixed_height_);
+  } else {

[vasilii, 2017/06/30 15:28:05]

DCHECK_EQ(EDITING, row_status_)?

[irmakk, 2017/07/03 14:56:54]

Done.

+    editable_ = GenerateUsernameEditable(*password_form_).release();
+    layout->AddView(editable_, 1, 1, views::GridLayout::FILL,
+                    views::GridLayout::FILL, 0, fixed_height_);
+    host_->GetFocusManager()->SetFocusedView(editable_);
+    host_->delegate_->FocusedOnEditable();
+    host_->GetFocusManager()->AddFocusChangeListener(this);
+  }
   layout->AddView(GeneratePasswordLabel(*password_form_).release(), 1, 1,
                   views::GridLayout::FILL, views::GridLayout::FILL,
                   0, fixed_height_);
   if (column_set_id == THREE_COLUMN_SET) {
     delete_button_ = GenerateDeleteButton(this).release();
     layout->AddView(delete_button_, 1, 1,
                     views::GridLayout::TRAILING, views::GridLayout::FILL,
                     0, fixed_height_);
   }
 }
@@ skipping 10 matching lines @@
                   views::GridLayout::FILL, views::GridLayout::FILL,
                   0, fixed_height_);
   layout->AddView(undo_link.release(), 1, 1,
                   views::GridLayout::FILL, views::GridLayout::FILL,
                   0, fixed_height_);
 }
 
 void ManagePasswordItemsView::PasswordFormRow::ButtonPressed(
     views::Button* sender, const ui::Event& event) {
   DCHECK_EQ(delete_button_, sender);
-  deleted_ = true;
-  host_->NotifyPasswordFormStatusChanged(*password_form_, deleted_);
+  row_status_ = RowStatus::DELETED;
+  host_->NotifyPasswordFormStatusChanged(*password_form_, true);
 }
 
 void ManagePasswordItemsView::PasswordFormRow::LinkClicked(views::Link* sender,
                                                            int event_flags) {
   DCHECK_EQ(undo_link_, sender);
-  deleted_ = false;
-  host_->NotifyPasswordFormStatusChanged(*password_form_, deleted_);
+  row_status_ = RowStatus::DEFAULT;
+  host_->NotifyPasswordFormStatusChanged(*password_form_, false);
 }
 
 void ManagePasswordItemsView::PasswordFormRow::ResetControls() {
   delete_button_ = nullptr;
   undo_link_ = nullptr;

[vasilii, 2017/06/30 15:28:06]

editable_ = nullptr;

[irmakk, 2017/07/03 14:56:53]

Done.

 }
 
+// FocusChangeListener methods.
+void ManagePasswordItemsView::PasswordFormRow::OnWillChangeFocus(

[vasilii, 2017/06/30 15:28:06]

The definition order should match the declaration order.
Same for the ManagePasswordItemsView's methods.

+    View* focused_before,
+    View* focused_now) {
+  // Nothing to do here.
+}
+
+void ManagePasswordItemsView::PasswordFormRow::OnDidChangeFocus(
+    View* focused_before,
+    View* focused_now) {
+  if (focused_before == editable_) {
+    host_->SetRowStatusForPendingViewRow(RowStatus::DEFAULT);
+  }
+}
+
 // ManagePasswordItemsView
 ManagePasswordItemsView::ManagePasswordItemsView(
     ManagePasswordsBubbleModel* manage_passwords_bubble_model,
     const std::vector<autofill::PasswordForm>* password_forms)
     : model_(manage_passwords_bubble_model) {
   int fixed_height = PasswordFormRow::GetFixedHeight(model_->state());
   for (const auto& password_form : *password_forms) {
     password_forms_rows_.push_back(base::MakeUnique<PasswordFormRow>(
         this, &password_form, fixed_height));
   }
   AddRows();
 }
 
 ManagePasswordItemsView::ManagePasswordItemsView(
     ManagePasswordsBubbleModel* manage_passwords_bubble_model,
-    const autofill::PasswordForm* password_form)
-    : model_(manage_passwords_bubble_model) {
+    const autofill::PasswordForm* password_form,
+    ManagePasswordItemsDelegate* manage_password_items_delegate)
+    : model_(manage_passwords_bubble_model),
+      delegate_(manage_password_items_delegate) {
   password_forms_rows_.push_back(
       base::MakeUnique<PasswordFormRow>(this, password_form, 0));
   AddRows();
 }
 
 ManagePasswordItemsView::~ManagePasswordItemsView() = default;
 
 void ManagePasswordItemsView::AddRows() {
   const int vertical_padding = ChromeLayoutProvider::Get()->GetDistanceMetric(
       views::DISTANCE_RELATED_CONTROL_VERTICAL);
@@ skipping 16 matching lines @@
                            deleted
                                ? ManagePasswordsBubbleModel::REMOVE_PASSWORD
                                : ManagePasswordsBubbleModel::ADD_PASSWORD);
 }
 
 void ManagePasswordItemsView::Refresh() {
   DCHECK_NE(password_manager::ui::PENDING_PASSWORD_STATE, model_->state());
   RemoveAllChildViews(true);
   AddRows();
 }
+
+bool ManagePasswordItemsView::OnKeyPressed(const ui::KeyEvent& event) {

[vasilii, 2017/06/30 15:28:05]

How does it work? The edit doesn't handle ENTER and ESC, therefore, we got the
event here?

+  // Handle key press if editable field is active, leave it to the parent
+  // otherwise.
+  if (password_manager::ui::PENDING_PASSWORD_STATE == model_->state() &&
+      password_forms_rows_[0]->row_status_ == RowStatus::EDITING &&
+      (event.key_code() == ui::KeyboardCode::VKEY_RETURN ||
+       event.key_code() == ui::KeyboardCode::VKEY_ESCAPE)) {
+    SetRowStatusForPendingViewRow(RowStatus::DEFAULT);
+    return true;
+  }
+  return false;
+}
+
+void ManagePasswordItemsView::SetRowStatusForPendingViewRow(
+    RowStatus row_status) {
+  DCHECK_EQ(password_manager::ui::PENDING_PASSWORD_STATE, model_->state());
+  const std::unique_ptr<PasswordFormRow>& row = password_forms_rows_[0];
+  if (row->row_status_ == RowStatus::EDITING &&
+      row_status == RowStatus::DEFAULT) {
+    GetFocusManager()->RemoveFocusChangeListener(row.get());

[vasilii, 2017/06/30 15:28:06]

I feel that it's wrong that it's not PasswordFormRow that unregisters itself.
PasswordFormRow should register once it enters the EDIT mode and unregister once
it leaves it or on destruction.

+    delegate_->FocusLostOnEditable();
+  }
+  row->row_status_ = row_status;
+  RemoveAllChildViews(true);
+  AddRows();
+}