Fix RTL: Omnibar - message "Press Tab to search Google" doesn't show correctly in a "New

chrome/browser/views/location_bar_view.cc

 // Copyright (c) 2009 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/views/location_bar_view.h"
 
 #if defined(OS_LINUX)
 #include <gtk/gtk.h>
 #endif
 
@@ skipping 402 matching lines @@
   RECT edit_bounds;
   location_entry_->GetClientRect(&edit_bounds);
   int max_edit_width = entry_width - formatting_rect.left -
                        (edit_bounds.right - formatting_rect.right);
 #else
   int max_edit_width = entry_width;
 #endif
 
   if (max_edit_width < 0)
     return;
-  const int text_width = TextDisplayWidth();
+  const int available_width = AvailableWidth(max_edit_width);
   bool needs_layout = force_layout;
-  needs_layout |= AdjustHints(text_width, max_edit_width);
+  needs_layout |= AdjustHints(available_width);
 
   if (!needs_layout)
     return;
 
   // TODO(sky): baseline layout.
   int location_y = TopMargin();
   int location_height = std::max(height() - location_y - kVertMargin, 0);
 
   // First set the bounds for the label that appears to the right of the
   // security icon.
@@ skipping 18 matching lines @@
       offset -= page_action_size.width();
       page_action_image_views_[i]->SetBounds(offset, location_y,
                                              page_action_size.width(),
                                              location_height);
       offset -= kInnerPadding;
     }
   }
   gfx::Rect location_bounds(kEntryPadding, location_y, entry_width,
                             location_height);
   if (selected_keyword_view_.IsVisible()) {
-    LayoutView(true, &selected_keyword_view_, text_width, max_edit_width,
+    LayoutView(true, &selected_keyword_view_, available_width,
                &location_bounds);
   } else if (keyword_hint_view_.IsVisible()) {
-    LayoutView(false, &keyword_hint_view_, text_width, max_edit_width,
+    LayoutView(false, &keyword_hint_view_, available_width,
                &location_bounds);
   } else if (type_to_search_view_.IsVisible()) {
-    LayoutView(false, &type_to_search_view_, text_width, max_edit_width,
+    LayoutView(false, &type_to_search_view_, available_width,
                &location_bounds);
   }
 
   location_entry_view_->SetBounds(location_bounds);
   if (!force_layout) {
     // If force_layout is false and we got this far it means one of the views
     // was added/removed or changed in size. We need to paint ourselves.
     SchedulePaint();
   }
 }
 
 int LocationBarView::TopMargin() const {
   return std::min(kVertMargin, height());
 }
 
-int LocationBarView::TextDisplayWidth() {
+int LocationBarView::AvailableWidth(int location_bar_width) {
 #if defined(OS_WIN)
-  POINT last_char_position =
-      location_entry_->PosFromChar(location_entry_->GetTextLength());
-  POINT scroll_position;
-  location_entry_->GetScrollPos(&scroll_position);
-  const int position_x = last_char_position.x + scroll_position.x;
-  return UILayoutIsRightToLeft() ? width() - position_x : position_x;
+  // Use font_.GetStringWidth() instead of
+  // PosFromChar(location_entry_->GetTextLength()) because PosFromChar() is
+  // apparently buggy. In both LTR UI and RTL UI with left-to-right layout,
+  // PosFromChar(i) might return 0 when i is greater than 1.
+  return std::max(
+      location_bar_width - font_.GetStringWidth(location_entry_->GetText()), 0);
 #else
   NOTIMPLEMENTED();
-  return 0;
+  return location_bar_width;
 #endif
 }
 
-bool LocationBarView::UsePref(int pref_width, int text_width, int max_width) {
-  return (pref_width + kInnerPadding + text_width <= max_width);
+bool LocationBarView::UsePref(int pref_width, int available_width) {
+  return (pref_width + kInnerPadding <= available_width);
 }
 
-bool LocationBarView::NeedsResize(View* view, int text_width, int max_width) {
+bool LocationBarView::NeedsResize(View* view, int available_width) {
   gfx::Size size = view->GetPreferredSize();
-  if (!UsePref(size.width(), text_width, max_width))
+  if (!UsePref(size.width(), available_width))
     size = view->GetMinimumSize();
   return (view->width() != size.width());
 }
 
-bool LocationBarView::AdjustHints(int text_width, int max_width) {
+bool LocationBarView::AdjustHints(int available_width) {
   const std::wstring keyword(location_entry_->model()->keyword());
   const bool is_keyword_hint(location_entry_->model()->is_keyword_hint());
   const bool show_selected_keyword = !keyword.empty() && !is_keyword_hint;
   const bool show_keyword_hint = !keyword.empty() && is_keyword_hint;
   bool show_search_hint(location_entry_->model()->show_search_hint());
   DCHECK(keyword.empty() || !show_search_hint);
 
   if (show_search_hint) {
     // Only show type to search if all the text fits.
     gfx::Size view_pref = type_to_search_view_.GetPreferredSize();
-    show_search_hint = UsePref(view_pref.width(), text_width, max_width);
+    show_search_hint = UsePref(view_pref.width(), available_width);
   }
 
   // NOTE: This isn't just one big || statement as ToggleVisibility MUST be
   // invoked for each view.
   bool needs_layout = false;
   needs_layout |= ToggleVisibility(show_selected_keyword,
                                    &selected_keyword_view_);
   needs_layout |= ToggleVisibility(show_keyword_hint, &keyword_hint_view_);
   needs_layout |= ToggleVisibility(show_search_hint, &type_to_search_view_);
   if (show_selected_keyword) {
     if (selected_keyword_view_.keyword() != keyword) {
       needs_layout = true;
       selected_keyword_view_.SetKeyword(keyword);
     }
-    needs_layout |= NeedsResize(&selected_keyword_view_, text_width, max_width);
+    needs_layout |= NeedsResize(&selected_keyword_view_, available_width);
   } else if (show_keyword_hint) {
     if (keyword_hint_view_.keyword() != keyword) {
       needs_layout = true;
       keyword_hint_view_.SetKeyword(keyword);
     }
-    needs_layout |= NeedsResize(&keyword_hint_view_, text_width, max_width);
+    needs_layout |= NeedsResize(&keyword_hint_view_, available_width);
   }
 
   return needs_layout;
 }
 
-void LocationBarView::LayoutView(bool leading, views::View* view,
-                                 int text_width, int max_width,
+void LocationBarView::LayoutView(bool leading,
+                                 views::View* view,
+                                 int available_width,
                                  gfx::Rect* bounds) {
   DCHECK(view && bounds);
   gfx::Size view_size = view->GetPreferredSize();
-  if (!UsePref(view_size.width(), text_width, max_width))
+  if (!UsePref(view_size.width(), available_width))
     view_size = view->GetMinimumSize();
   if (view_size.width() + kInnerPadding < bounds->width()) {
     view->SetVisible(true);
     if (leading) {
       view->SetBounds(bounds->x(), bounds->y(), view_size.width(),
                       bounds->height());
       bounds->Offset(view_size.width() + kInnerPadding, 0);
     } else {
       view->SetBounds(bounds->right() - view_size.width(), bounds->y(),
                       view_size.width(), bounds->height());
@@ skipping 805 matching lines @@
 }
 
 int LocationBarView::PageActionVisibleCount() {
   int result = 0;
   for (size_t i = 0; i < page_action_image_views_.size(); i++) {
     if (page_action_image_views_[i]->IsVisible())
       ++result;
   }
   return result;
 }