chrome/browser/ui/autofill/autofill_popup_controller_impl.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/ui/autofill/autofill_popup_controller_impl.h"
   6
   7 #include <algorithm>
   8 #include <utility>
   9
  10 #include "base/logging.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "chrome/browser/ui/autofill/autofill_popup_view.h"
  13 #include "chrome/browser/ui/autofill/popup_constants.h"
  14 #include "components/autofill/core/browser/autofill_popup_delegate.h"
  15 #include "components/autofill/core/browser/popup_item_ids.h"
  16 #include "components/autofill/core/browser/suggestion.h"
  17 #include "content/public/browser/native_web_keyboard_event.h"
  18 #include "grit/components_scaled_resources.h"
  19 #include "ui/base/resource/resource_bundle.h"
  20 #include "ui/events/event.h"
  21 #include "ui/gfx/geometry/rect_conversions.h"
  22 #include "ui/gfx/geometry/vector2d.h"
  23 #include "ui/gfx/screen.h"
  24 #include "ui/gfx/text_elider.h"
  25 #include "ui/gfx/text_utils.h"
  26
  27 using base::WeakPtr;
  28
  29 namespace autofill {
  30 namespace {
  31
  32 // Used to indicate that no line is currently selected by the user.
  33 const int kNoSelection = -1;
  34
  35 // The vertical height of each row in pixels.
  36 const size_t kRowHeight = 24;
  37
  38 // The vertical height of a separator in pixels.
  39 const size_t kSeparatorHeight = 1;
  40
  41 #if !defined(OS_ANDROID)
  42 // Size difference between name and label in pixels.
  43 const int kLabelFontSizeDelta = -2;
  44
  45 const size_t kNamePadding = AutofillPopupView::kNamePadding;
  46 const size_t kIconPadding = AutofillPopupView::kIconPadding;
  47 const size_t kEndPadding = AutofillPopupView::kEndPadding;
  48 #endif
  49
  50 struct DataResource {
  51   const char* name;
  52   int id;
  53 };
  54
  55 const DataResource kDataResources[] = {
  56   { "americanExpressCC", IDR_AUTOFILL_CC_AMEX },
  57   { "dinersCC", IDR_AUTOFILL_CC_GENERIC },
  58   { "discoverCC", IDR_AUTOFILL_CC_DISCOVER },
  59   { "genericCC", IDR_AUTOFILL_CC_GENERIC },
  60   { "jcbCC", IDR_AUTOFILL_CC_GENERIC },
  61   { "masterCardCC", IDR_AUTOFILL_CC_MASTERCARD },
  62   { "visaCC", IDR_AUTOFILL_CC_VISA },
  63   { "scanCreditCardIcon", IDR_AUTOFILL_CC_SCAN_NEW },
  64 #if defined(OS_MACOSX) && !defined(OS_IOS)
  65   { "macContactsIcon", IDR_AUTOFILL_MAC_CONTACTS_ICON },
  66 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
  67 };
  68
  69 }  // namespace
  70
  71 // static
  72 WeakPtr<AutofillPopupControllerImpl> AutofillPopupControllerImpl::GetOrCreate(
  73     WeakPtr<AutofillPopupControllerImpl> previous,
  74     WeakPtr<AutofillPopupDelegate> delegate,
  75     content::WebContents* web_contents,
  76     gfx::NativeView container_view,
  77     const gfx::RectF& element_bounds,
  78     base::i18n::TextDirection text_direction) {
  79   if (previous.get() && previous->web_contents() == web_contents &&
  80       previous->delegate_.get() == delegate.get() &&
  81       previous->container_view() == container_view &&
  82       previous->element_bounds() == element_bounds) {
  83     previous->ClearState();
  84     return previous;
  85   }
  86
  87   if (previous.get())
  88     previous->Hide();
  89
  90   AutofillPopupControllerImpl* controller =
  91       new AutofillPopupControllerImpl(
  92           delegate, web_contents, container_view, element_bounds,
  93           text_direction);
  94   return controller->GetWeakPtr();
  95 }
  96
  97 AutofillPopupControllerImpl::AutofillPopupControllerImpl(
  98     base::WeakPtr<AutofillPopupDelegate> delegate,
  99     content::WebContents* web_contents,
 100     gfx::NativeView container_view,
 101     const gfx::RectF& element_bounds,
 102     base::i18n::TextDirection text_direction)
 103     : controller_common_(new PopupControllerCommon(element_bounds,
 104                                                    text_direction,
 105                                                    container_view,
 106                                                    web_contents)),
 107       view_(NULL),
 108       delegate_(delegate),
 109       weak_ptr_factory_(this) {
 110   ClearState();
 111   controller_common_->SetKeyPressCallback(
 112       base::Bind(&AutofillPopupControllerImpl::HandleKeyPressEvent,
 113                  base::Unretained(this)));
 114 #if !defined(OS_ANDROID)
 115   label_font_list_ = value_font_list_.DeriveWithSizeDelta(kLabelFontSizeDelta);
 116   title_font_list_ = value_font_list_.DeriveWithStyle(gfx::Font::BOLD);
 117 #if defined(OS_MACOSX)
 118   // There is no italic version of the system font.
 119   warning_font_list_ = value_font_list_;
 120 #else
 121   warning_font_list_ = value_font_list_.DeriveWithStyle(gfx::Font::ITALIC);
 122 #endif
 123 #endif
 124 }
 125
 126 AutofillPopupControllerImpl::~AutofillPopupControllerImpl() {}
 127
 128 void AutofillPopupControllerImpl::Show(
 129     const std::vector<autofill::Suggestion>& suggestions) {
 130   SetValues(suggestions);
 131   DCHECK_EQ(suggestions_.size(), elided_values_.size());
 132   DCHECK_EQ(suggestions_.size(), elided_labels_.size());
 133
 134 #if !defined(OS_ANDROID)
 135   // Android displays the long text with ellipsis using the view attributes.
 136
 137   UpdatePopupBounds();
 138   int popup_width = popup_bounds().width();
 139
 140   // Elide the name and label strings so that the popup fits in the available
 141   // space.
 142   for (size_t i = 0; i < suggestions_.size(); ++i) {
 143     int value_width =
 144         gfx::GetStringWidth(suggestions_[i].value, GetValueFontListForRow(i));
 145     int label_width =
 146         gfx::GetStringWidth(suggestions_[i].label, GetLabelFontList());
 147     int total_text_length = value_width + label_width;
 148
 149     // The line can have no strings if it represents a UI element, such as
 150     // a separator line.
 151     if (total_text_length == 0)
 152       continue;
 153
 154     int available_width = popup_width - RowWidthWithoutText(i);
 155
 156     // Each field receives space in proportion to its length.
 157     int value_size = available_width * value_width / total_text_length;
 158     elided_values_[i] = gfx::ElideText(suggestions_[i].value,
 159                                        GetValueFontListForRow(i),
 160                                        value_size, gfx::ELIDE_TAIL);
 161
 162     int label_size = available_width * label_width / total_text_length;
 163     elided_labels_[i] = gfx::ElideText(suggestions_[i].label,
 164                                        GetLabelFontList(),
 165                                        label_size, gfx::ELIDE_TAIL);
 166   }
 167 #endif
 168
 169   if (!view_) {
 170     view_ = AutofillPopupView::Create(this);
 171
 172     // It is possible to fail to create the popup, in this case
 173     // treat the popup as hiding right away.
 174     if (!view_) {
 175       Hide();
 176       return;
 177     }
 178
 179     ShowView();
 180   } else {
 181     UpdateBoundsAndRedrawPopup();
 182   }
 183
 184   controller_common_->RegisterKeyPressCallback();
 185   delegate_->OnPopupShown();
 186
 187   DCHECK_EQ(suggestions_.size(), elided_values_.size());
 188   DCHECK_EQ(suggestions_.size(), elided_labels_.size());
 189 }
 190
 191 void AutofillPopupControllerImpl::UpdateDataListValues(
 192     const std::vector<base::string16>& values,
 193     const std::vector<base::string16>& labels) {
 194   DCHECK_EQ(suggestions_.size(), elided_values_.size());
 195   DCHECK_EQ(suggestions_.size(), elided_labels_.size());
 196
 197   // Remove all the old data list values, which should always be at the top of
 198   // the list if they are present.
 199   while (!suggestions_.empty() &&
 200          suggestions_[0].frontend_id == POPUP_ITEM_ID_DATALIST_ENTRY) {
 201     suggestions_.erase(suggestions_.begin());
 202     elided_values_.erase(elided_values_.begin());
 203     elided_labels_.erase(elided_labels_.begin());
 204   }
 205
 206   // If there are no new data list values, exit (clearing the separator if there
 207   // is one).
 208   if (values.empty()) {
 209     if (!suggestions_.empty() &&
 210         suggestions_[0].frontend_id == POPUP_ITEM_ID_SEPARATOR) {
 211       suggestions_.erase(suggestions_.begin());
 212       elided_values_.erase(elided_values_.begin());
 213       elided_labels_.erase(elided_labels_.begin());
 214     }
 215
 216      // The popup contents have changed, so either update the bounds or hide it.
 217     if (HasSuggestions())
 218       UpdateBoundsAndRedrawPopup();
 219     else
 220       Hide();
 221
 222     return;
 223   }
 224
 225   // Add a separator if there are any other values.
 226   if (!suggestions_.empty() &&
 227       suggestions_[0].frontend_id != POPUP_ITEM_ID_SEPARATOR) {
 228     suggestions_.insert(suggestions_.begin(), autofill::Suggestion());
 229     suggestions_[0].frontend_id = POPUP_ITEM_ID_SEPARATOR;
 230     elided_values_.insert(elided_values_.begin(), base::string16());
 231     elided_labels_.insert(elided_labels_.begin(), base::string16());
 232   }
 233
 234   // Prepend the parameters to the suggestions we already have.
 235   suggestions_.insert(suggestions_.begin(), values.size(), Suggestion());
 236   elided_values_.insert(elided_values_.begin(), values.size(),
 237                         base::string16());
 238   elided_labels_.insert(elided_labels_.begin(), values.size(),
 239                         base::string16());
 240   for (size_t i = 0; i < values.size(); i++) {
 241     suggestions_[i].value = values[i];
 242     suggestions_[i].label = labels[i];
 243     suggestions_[i].frontend_id = POPUP_ITEM_ID_DATALIST_ENTRY;
 244
 245     // TODO(brettw) it looks like these should be elided.
 246     elided_values_[i] = values[i];
 247     elided_labels_[i] = labels[i];
 248   }
 249
 250   UpdateBoundsAndRedrawPopup();
 251   DCHECK_EQ(suggestions_.size(), elided_values_.size());
 252   DCHECK_EQ(suggestions_.size(), elided_labels_.size());
 253 }
 254
 255 void AutofillPopupControllerImpl::Hide() {
 256   controller_common_->RemoveKeyPressCallback();
 257   if (delegate_)
 258     delegate_->OnPopupHidden();
 259
 260   if (view_)
 261     view_->Hide();
 262
 263   delete this;
 264 }
 265
 266 void AutofillPopupControllerImpl::ViewDestroyed() {
 267   // The view has already been destroyed so clear the reference to it.
 268   view_ = NULL;
 269
 270   Hide();
 271 }
 272
 273 bool AutofillPopupControllerImpl::HandleKeyPressEvent(
 274     const content::NativeWebKeyboardEvent& event) {
 275   switch (event.windowsKeyCode) {
 276     case ui::VKEY_UP:
 277       SelectPreviousLine();
 278       return true;
 279     case ui::VKEY_DOWN:
 280       SelectNextLine();
 281       return true;
 282     case ui::VKEY_PRIOR:  // Page up.
 283       // Set no line and then select the next line in case the first line is not
 284       // selectable.
 285       SetSelectedLine(kNoSelection);
 286       SelectNextLine();
 287       return true;
 288     case ui::VKEY_NEXT:  // Page down.
 289       SetSelectedLine(GetLineCount() - 1);
 290       return true;
 291     case ui::VKEY_ESCAPE:
 292       Hide();
 293       return true;
 294     case ui::VKEY_DELETE:
 295       return (event.modifiers & content::NativeWebKeyboardEvent::ShiftKey) &&
 296              RemoveSelectedLine();
 297     case ui::VKEY_TAB:
 298       // A tab press should cause the selected line to be accepted, but still
 299       // return false so the tab key press propagates and changes the cursor
 300       // location.
 301       AcceptSelectedLine();
 302       return false;
 303     case ui::VKEY_RETURN:
 304       return AcceptSelectedLine();
 305     default:
 306       return false;
 307   }
 308 }
 309
 310 void AutofillPopupControllerImpl::UpdateBoundsAndRedrawPopup() {
 311 #if !defined(OS_ANDROID)
 312   // TODO(csharp): Since UpdatePopupBounds can change the position of the popup,
 313   // the popup could end up jumping from above the element to below it.
 314   // It is unclear if it is better to keep the popup where it was, or if it
 315   // should try and move to its desired position.
 316   UpdatePopupBounds();
 317 #endif
 318
 319   view_->UpdateBoundsAndRedrawPopup();
 320 }
 321
 322 void AutofillPopupControllerImpl::SetSelectionAtPoint(const gfx::Point& point) {
 323   SetSelectedLine(LineFromY(point.y()));
 324 }
 325
 326 bool AutofillPopupControllerImpl::AcceptSelectedLine() {
 327   if (selected_line_ == kNoSelection)
 328     return false;
 329
 330   DCHECK_GE(selected_line_, 0);
 331   DCHECK_LT(selected_line_, static_cast<int>(GetLineCount()));
 332
 333   if (!CanAccept(suggestions_[selected_line_].frontend_id))
 334     return false;
 335
 336   AcceptSuggestion(selected_line_);
 337   return true;
 338 }
 339
 340 void AutofillPopupControllerImpl::SelectionCleared() {
 341   SetSelectedLine(kNoSelection);
 342 }
 343
 344 void AutofillPopupControllerImpl::AcceptSuggestion(size_t index) {
 345   const autofill::Suggestion& suggestion = suggestions_[index];
 346   delegate_->DidAcceptSuggestion(suggestion.value, suggestion.frontend_id);
 347 }
 348
 349 int AutofillPopupControllerImpl::GetIconResourceID(
 350     const base::string16& resource_name) const {
 351   for (size_t i = 0; i < arraysize(kDataResources); ++i) {
 352     if (resource_name == base::ASCIIToUTF16(kDataResources[i].name))
 353       return kDataResources[i].id;
 354   }
 355
 356   return -1;
 357 }
 358
 359 bool AutofillPopupControllerImpl::IsWarning(size_t index) const {
 360   return suggestions_[index].frontend_id == POPUP_ITEM_ID_WARNING_MESSAGE;
 361 }
 362
 363 gfx::Rect AutofillPopupControllerImpl::GetRowBounds(size_t index) {
 364   int top = kPopupBorderThickness;
 365   for (size_t i = 0; i < index; ++i) {
 366     top += GetRowHeightFromId(suggestions_[i].frontend_id);
 367   }
 368
 369   return gfx::Rect(
 370       kPopupBorderThickness,
 371       top,
 372       popup_bounds_.width() - 2 * kPopupBorderThickness,
 373       GetRowHeightFromId(suggestions_[index].frontend_id));
 374 }
 375
 376 void AutofillPopupControllerImpl::SetPopupBounds(const gfx::Rect& bounds) {
 377   popup_bounds_ = bounds;
 378   UpdateBoundsAndRedrawPopup();
 379 }
 380
 381 const gfx::Rect& AutofillPopupControllerImpl::popup_bounds() const {
 382   return popup_bounds_;
 383 }
 384
 385 content::WebContents* AutofillPopupControllerImpl::web_contents() {
 386   return controller_common_->web_contents();
 387 }
 388
 389 gfx::NativeView AutofillPopupControllerImpl::container_view() {
 390   return controller_common_->container_view();
 391 }
 392
 393 const gfx::RectF& AutofillPopupControllerImpl::element_bounds() const {
 394   return controller_common_->element_bounds();
 395 }
 396
 397 bool AutofillPopupControllerImpl::IsRTL() const {
 398   return controller_common_->is_rtl();
 399 }
 400
 401 size_t AutofillPopupControllerImpl::GetLineCount() const {
 402   return suggestions_.size();
 403 }
 404
 405 const autofill::Suggestion& AutofillPopupControllerImpl::GetSuggestionAt(
 406     size_t row) const {
 407   return suggestions_[row];
 408 }
 409
 410 const base::string16& AutofillPopupControllerImpl::GetElidedValueAt(
 411     size_t row) const {
 412   return elided_values_[row];
 413 }
 414
 415 const base::string16& AutofillPopupControllerImpl::GetElidedLabelAt(
 416     size_t row) const {
 417   return elided_labels_[row];
 418 }
 419
 420 bool AutofillPopupControllerImpl::GetRemovalConfirmationText(
 421     int list_index,
 422     base::string16* title,
 423     base::string16* body) {
 424   return delegate_->GetDeletionConfirmationText(
 425       suggestions_[list_index].value, suggestions_[list_index].frontend_id,
 426       title, body);
 427 }
 428
 429 bool AutofillPopupControllerImpl::RemoveSuggestion(int list_index) {
 430   if (!delegate_->RemoveSuggestion(suggestions_[list_index].value,
 431                                    suggestions_[list_index].frontend_id)) {
 432     return false;
 433   }
 434
 435   // Remove the deleted element.
 436   suggestions_.erase(suggestions_.begin() + list_index);
 437   elided_values_.erase(elided_values_.begin() + list_index);
 438   elided_labels_.erase(elided_labels_.begin() + list_index);
 439
 440   SetSelectedLine(kNoSelection);
 441
 442   if (HasSuggestions()) {
 443     delegate_->ClearPreviewedForm();
 444     UpdateBoundsAndRedrawPopup();
 445   } else {
 446     Hide();
 447   }
 448
 449   return true;
 450 }
 451
 452 #if !defined(OS_ANDROID)
 453 const gfx::FontList& AutofillPopupControllerImpl::GetValueFontListForRow(
 454     size_t index) const {
 455   if (suggestions_[index].frontend_id == POPUP_ITEM_ID_WARNING_MESSAGE)
 456     return warning_font_list_;
 457
 458   if (suggestions_[index].frontend_id == POPUP_ITEM_ID_TITLE)
 459     return title_font_list_;
 460
 461   return value_font_list_;
 462 }
 463
 464 const gfx::FontList& AutofillPopupControllerImpl::GetLabelFontList() const {
 465   return label_font_list_;
 466 }
 467 #endif
 468
 469 int AutofillPopupControllerImpl::selected_line() const {
 470   return selected_line_;
 471 }
 472
 473 void AutofillPopupControllerImpl::SetSelectedLine(int selected_line) {
 474   if (selected_line_ == selected_line)
 475     return;
 476
 477   if (selected_line_ != kNoSelection &&
 478       static_cast<size_t>(selected_line_) < suggestions_.size())
 479     InvalidateRow(selected_line_);
 480
 481   if (selected_line != kNoSelection) {
 482     InvalidateRow(selected_line);
 483
 484     if (!CanAccept(suggestions_[selected_line].frontend_id))
 485       selected_line = kNoSelection;
 486   }
 487
 488   selected_line_ = selected_line;
 489
 490   if (selected_line_ != kNoSelection) {
 491     delegate_->DidSelectSuggestion(suggestions_[selected_line_].value,
 492                                    suggestions_[selected_line_].frontend_id);
 493   } else {
 494     delegate_->ClearPreviewedForm();
 495   }
 496 }
 497
 498 void AutofillPopupControllerImpl::SelectNextLine() {
 499   int new_selected_line = selected_line_ + 1;
 500
 501   // Skip over any lines that can't be selected.
 502   while (static_cast<size_t>(new_selected_line) < GetLineCount() &&
 503          !CanAccept(suggestions_[new_selected_line].frontend_id)) {
 504     ++new_selected_line;
 505   }
 506
 507   if (new_selected_line >= static_cast<int>(GetLineCount()))
 508     new_selected_line = 0;
 509
 510   SetSelectedLine(new_selected_line);
 511 }
 512
 513 void AutofillPopupControllerImpl::SelectPreviousLine() {
 514   int new_selected_line = selected_line_ - 1;
 515
 516   // Skip over any lines that can't be selected.
 517   while (new_selected_line > kNoSelection &&
 518          !CanAccept(GetSuggestionAt(new_selected_line).frontend_id)) {
 519     --new_selected_line;
 520   }
 521
 522   if (new_selected_line <= kNoSelection)
 523     new_selected_line = GetLineCount() - 1;
 524
 525   SetSelectedLine(new_selected_line);
 526 }
 527
 528 bool AutofillPopupControllerImpl::RemoveSelectedLine() {
 529   if (selected_line_ == kNoSelection)
 530     return false;
 531
 532   DCHECK_GE(selected_line_, 0);
 533   DCHECK_LT(selected_line_, static_cast<int>(GetLineCount()));
 534   return RemoveSuggestion(selected_line_);
 535 }
 536
 537 int AutofillPopupControllerImpl::LineFromY(int y) {
 538   int current_height = kPopupBorderThickness;
 539
 540   for (size_t i = 0; i < suggestions_.size(); ++i) {
 541     current_height += GetRowHeightFromId(suggestions_[i].frontend_id);
 542
 543     if (y <= current_height)
 544       return i;
 545   }
 546
 547   // The y value goes beyond the popup so stop the selection at the last line.
 548   return GetLineCount() - 1;
 549 }
 550
 551 int AutofillPopupControllerImpl::GetRowHeightFromId(int identifier) const {
 552   if (identifier == POPUP_ITEM_ID_SEPARATOR)
 553     return kSeparatorHeight;
 554
 555   return kRowHeight;
 556 }
 557
 558 bool AutofillPopupControllerImpl::CanAccept(int id) {
 559   return id != POPUP_ITEM_ID_SEPARATOR && id != POPUP_ITEM_ID_WARNING_MESSAGE &&
 560          id != POPUP_ITEM_ID_TITLE;
 561 }
 562
 563 bool AutofillPopupControllerImpl::HasSuggestions() {
 564   if (suggestions_.empty())
 565     return false;
 566   int id = suggestions_[0].frontend_id;
 567   return id > 0 ||
 568          id == POPUP_ITEM_ID_AUTOCOMPLETE_ENTRY ||
 569          id == POPUP_ITEM_ID_PASSWORD_ENTRY ||
 570          id == POPUP_ITEM_ID_DATALIST_ENTRY ||
 571          id == POPUP_ITEM_ID_MAC_ACCESS_CONTACTS ||
 572          id == POPUP_ITEM_ID_SCAN_CREDIT_CARD;
 573 }
 574
 575 void AutofillPopupControllerImpl::SetValues(
 576     const std::vector<autofill::Suggestion>& suggestions) {
 577   suggestions_ = suggestions;
 578   elided_values_.resize(suggestions.size());
 579   elided_labels_.resize(suggestions.size());
 580   for (size_t i = 0; i < suggestions.size(); i++) {
 581     elided_values_[i] = suggestions[i].value;
 582     elided_labels_[i] = suggestions[i].label;
 583   }
 584 }
 585
 586 void AutofillPopupControllerImpl::ShowView() {
 587   view_->Show();
 588 }
 589
 590 void AutofillPopupControllerImpl::InvalidateRow(size_t row) {
 591   DCHECK(0 <= row);
 592   DCHECK(row < suggestions_.size());
 593   view_->InvalidateRow(row);
 594 }
 595
 596 #if !defined(OS_ANDROID)
 597 int AutofillPopupControllerImpl::GetDesiredPopupWidth() const {
 598   int popup_width = controller_common_->RoundedElementBounds().width();
 599   for (size_t i = 0; i < GetLineCount(); ++i) {
 600     int row_size =
 601         gfx::GetStringWidth(GetElidedValueAt(i), value_font_list_) +
 602         gfx::GetStringWidth(GetElidedLabelAt(i), label_font_list_) +
 603         RowWidthWithoutText(i);
 604
 605     popup_width = std::max(popup_width, row_size);
 606   }
 607
 608   return popup_width;
 609 }
 610
 611 int AutofillPopupControllerImpl::GetDesiredPopupHeight() const {
 612   int popup_height = 2 * kPopupBorderThickness;
 613
 614   for (size_t i = 0; i < suggestions_.size(); ++i) {
 615     popup_height += GetRowHeightFromId(suggestions_[i].frontend_id);
 616   }
 617
 618   return popup_height;
 619 }
 620
 621 int AutofillPopupControllerImpl::RowWidthWithoutText(int row) const {
 622   int row_size = kEndPadding;
 623
 624   if (!elided_labels_[row].empty())
 625     row_size += kNamePadding;
 626
 627   // Add the Autofill icon size, if required.
 628   const base::string16& icon = suggestions_[row].icon;
 629   if (!icon.empty()) {
 630     int icon_width = ui::ResourceBundle::GetSharedInstance().GetImageNamed(
 631         GetIconResourceID(icon)).Width();
 632     row_size += icon_width + kIconPadding;
 633   }
 634
 635   // Add the padding at the end.
 636   row_size += kEndPadding;
 637
 638   // Add room for the popup border.
 639   row_size += 2 * kPopupBorderThickness;
 640
 641   return row_size;
 642 }
 643
 644 void AutofillPopupControllerImpl::UpdatePopupBounds() {
 645   int popup_width = GetDesiredPopupWidth();
 646   int popup_height = GetDesiredPopupHeight();
 647
 648   popup_bounds_ = controller_common_->GetPopupBounds(popup_width, popup_height);
 649 }
 650 #endif  // !defined(OS_ANDROID)
 651
 652 WeakPtr<AutofillPopupControllerImpl> AutofillPopupControllerImpl::GetWeakPtr() {
 653   return weak_ptr_factory_.GetWeakPtr();
 654 }
 655
 656 void AutofillPopupControllerImpl::ClearState() {
 657   // Don't clear view_, because otherwise the popup will have to get regenerated
 658   // and this will cause flickering.
 659
 660   popup_bounds_ = gfx::Rect();
 661
 662   suggestions_.clear();
 663   elided_values_.clear();
 664   elided_labels_.clear();
 665
 666   selected_line_ = kNoSelection;
 667 }
 668
 669 }  // namespace autofill