Home | History | Annotate | Download | only in location_bar 
      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/views/location_bar/location_bar_view.h"
      6 
      7 #include <algorithm>
      8 #include <map>
      9 
     10 #include "base/command_line.h"
     11 #include "base/i18n/rtl.h"
     12 #include "base/prefs/pref_service.h"
     13 #include "base/stl_util.h"
     14 #include "base/strings/utf_string_conversions.h"
     15 #include "chrome/app/chrome_command_ids.h"
     16 #include "chrome/browser/chrome_notification_types.h"
     17 #include "chrome/browser/command_updater.h"
     18 #include "chrome/browser/defaults.h"
     19 #include "chrome/browser/extensions/api/omnibox/omnibox_api.h"
     20 #include "chrome/browser/extensions/location_bar_controller.h"
     21 #include "chrome/browser/extensions/script_bubble_controller.h"
     22 #include "chrome/browser/extensions/tab_helper.h"
     23 #include "chrome/browser/favicon/favicon_tab_helper.h"
     24 #include "chrome/browser/profiles/profile.h"
     25 #include "chrome/browser/search_engines/template_url.h"
     26 #include "chrome/browser/search_engines/template_url_service.h"
     27 #include "chrome/browser/search_engines/template_url_service_factory.h"
     28 #include "chrome/browser/ui/browser.h"
     29 #include "chrome/browser/ui/browser_finder.h"
     30 #include "chrome/browser/ui/browser_instant_controller.h"
     31 #include "chrome/browser/ui/browser_window.h"
     32 #include "chrome/browser/ui/omnibox/alternate_nav_url_fetcher.h"
     33 #include "chrome/browser/ui/omnibox/location_bar_util.h"
     34 #include "chrome/browser/ui/omnibox/omnibox_popup_model.h"
     35 #include "chrome/browser/ui/omnibox/omnibox_popup_view.h"
     36 #include "chrome/browser/ui/tabs/tab_strip_model.h"
     37 #include "chrome/browser/ui/view_ids.h"
     38 #include "chrome/browser/ui/views/bookmarks/bookmark_prompt_view.h"
     39 #include "chrome/browser/ui/views/browser_dialogs.h"
     40 #include "chrome/browser/ui/views/extensions/extension_popup.h"
     41 #include "chrome/browser/ui/views/location_bar/content_setting_image_view.h"
     42 #include "chrome/browser/ui/views/location_bar/ev_bubble_view.h"
     43 #include "chrome/browser/ui/views/location_bar/generated_credit_card_view.h"
     44 #include "chrome/browser/ui/views/location_bar/keyword_hint_view.h"
     45 #include "chrome/browser/ui/views/location_bar/location_bar_layout.h"
     46 #include "chrome/browser/ui/views/location_bar/location_icon_view.h"
     47 #include "chrome/browser/ui/views/location_bar/open_pdf_in_reader_view.h"
     48 #include "chrome/browser/ui/views/location_bar/page_action_image_view.h"
     49 #include "chrome/browser/ui/views/location_bar/page_action_with_badge_view.h"
     50 #include "chrome/browser/ui/views/location_bar/script_bubble_icon_view.h"
     51 #include "chrome/browser/ui/views/location_bar/selected_keyword_view.h"
     52 #include "chrome/browser/ui/views/location_bar/star_view.h"
     53 #include "chrome/browser/ui/views/location_bar/zoom_bubble_view.h"
     54 #include "chrome/browser/ui/views/location_bar/zoom_view.h"
     55 #include "chrome/browser/ui/views/omnibox/omnibox_view_views.h"
     56 #include "chrome/browser/ui/views/omnibox/omnibox_views.h"
     57 #include "chrome/browser/ui/zoom/zoom_controller.h"
     58 #include "chrome/common/extensions/feature_switch.h"
     59 #include "chrome/common/pref_names.h"
     60 #include "content/public/browser/notification_service.h"
     61 #include "content/public/browser/render_widget_host_view.h"
     62 #include "content/public/browser/web_contents.h"
     63 #include "grit/generated_resources.h"
     64 #include "grit/theme_resources.h"
     65 #include "ui/base/accessibility/accessible_view_state.h"
     66 #include "ui/base/dragdrop/drag_drop_types.h"
     67 #include "ui/base/events/event.h"
     68 #include "ui/base/l10n/l10n_util.h"
     69 #include "ui/base/layout.h"
     70 #include "ui/base/resource/resource_bundle.h"
     71 #include "ui/base/theme_provider.h"
     72 #include "ui/gfx/canvas.h"
     73 #include "ui/gfx/color_utils.h"
     74 #include "ui/gfx/image/image.h"
     75 #include "ui/gfx/image/image_skia_operations.h"
     76 #include "ui/gfx/skia_util.h"
     77 #include "ui/native_theme/native_theme.h"
     78 #include "ui/views/background.h"
     79 #include "ui/views/border.h"
     80 #include "ui/views/button_drag_utils.h"
     81 #include "ui/views/controls/button/image_button.h"
     82 #include "ui/views/controls/label.h"
     83 #include "ui/views/controls/textfield/textfield.h"
     84 #include "ui/views/widget/widget.h"
     85 #include "ui/views/window/non_client_view.h"
     86 
     87 #if defined(OS_WIN)
     88 #include "base/win/scoped_hdc.h"
     89 #include "base/win/scoped_select_object.h"
     90 #include "ui/native_theme/native_theme_win.h"
     91 #endif
     92 
     93 #if defined(OS_WIN) && !defined(USE_AURA)
     94 #include "chrome/browser/ui/views/omnibox/omnibox_view_win.h"
     95 #endif
     96 
     97 #if !defined(OS_CHROMEOS)
     98 #include "chrome/browser/ui/views/first_run_bubble.h"
     99 #endif
    100 
    101 #if defined(USE_AURA)
    102 #include "ui/compositor/layer.h"
    103 #include "ui/compositor/scoped_layer_animation_settings.h"
    104 #endif
    105 
    106 using content::WebContents;
    107 using views::View;
    108 
    109 
    110 namespace {
    111 
    112 Browser* GetBrowserFromDelegate(LocationBarView::Delegate* delegate) {
    113   WebContents* contents = delegate->GetWebContents();
    114   return contents ? chrome::FindBrowserWithWebContents(contents) : NULL;
    115 }
    116 
    117 // Given a containing |height| and a base |font_list|, shrinks the fonts until
    118 // the primary font will fit within |height| while having its cap height
    119 // vertically centered.  Returns the |font_y_offset| needed to produce this
    120 // centering.
    121 void CalculateFontAndOffsetForHeight(int height,
    122                                      gfx::FontList* font_list,
    123                                      int* font_y_offset) {
    124 #if defined(OS_WIN)
    125   base::win::ScopedGetDC screen_dc(NULL);
    126 #endif
    127 
    128   while (true) {
    129     // TODO(pkasting): Expand the gfx::Font metrics (and underlying Skia
    130     // metrics) enough to expose the cap height directly.
    131 #if defined(OS_WIN)
    132     const gfx::Font& font = font_list->GetPrimaryFont();
    133     base::win::ScopedSelectObject font_in_dc(screen_dc, font.GetNativeFont());
    134     TEXTMETRIC tm = {0};
    135     GetTextMetrics(screen_dc, &tm);
    136     int cap_height = font.GetBaseline() - tm.tmInternalLeading;
    137     *font_y_offset = ((height - cap_height) / 2) - tm.tmInternalLeading;
    138 #else
    139     // Without cap height available, we fall back to centering the full height.
    140     *font_y_offset = (height - font_list->GetHeight()) / 2;
    141 #endif
    142 
    143     const int font_size = font_list->GetFontSize();
    144     if (((*font_y_offset >= 0) &&
    145          ((*font_y_offset + font_list->GetHeight()) <= height)) ||
    146         (font_size <= 1))
    147       return;
    148     *font_list = font_list->DeriveFontListWithSize(font_size - 1);
    149   }
    150 }
    151 
    152 }  // namespace
    153 
    154 
    155 // LocationBarView -----------------------------------------------------------
    156 
    157 // static
    158 const int LocationBarView::kNormalEdgeThickness = 2;
    159 const int LocationBarView::kPopupEdgeThickness = 1;
    160 const int LocationBarView::kIconInternalPadding = 2;
    161 const int LocationBarView::kBubblePadding = 1;
    162 const char LocationBarView::kViewClassName[] = "LocationBarView";
    163 
    164 LocationBarView::LocationBarView(Browser* browser,
    165                                  Profile* profile,
    166                                  CommandUpdater* command_updater,
    167                                  ToolbarModel* model,
    168                                  Delegate* delegate,
    169                                  bool is_popup_mode)
    170     : browser_(browser),
    171       profile_(profile),
    172       command_updater_(command_updater),
    173       model_(model),
    174       delegate_(delegate),
    175       disposition_(CURRENT_TAB),
    176       transition_(content::PageTransitionFromInt(
    177           content::PAGE_TRANSITION_TYPED |
    178           content::PAGE_TRANSITION_FROM_ADDRESS_BAR)),
    179       location_icon_view_(NULL),
    180       ev_bubble_view_(NULL),
    181       location_entry_view_(NULL),
    182       ime_inline_autocomplete_view_(NULL),
    183       selected_keyword_view_(NULL),
    184       suggested_text_view_(NULL),
    185       keyword_hint_view_(NULL),
    186       mic_search_view_(NULL),
    187       zoom_view_(NULL),
    188       generated_credit_card_view_(NULL),
    189       open_pdf_in_reader_view_(NULL),
    190       script_bubble_icon_view_(NULL),
    191       star_view_(NULL),
    192       is_popup_mode_(is_popup_mode),
    193       show_focus_rect_(false),
    194       template_url_service_(NULL),
    195       animation_offset_(0),
    196       weak_ptr_factory_(this) {
    197   if (!views::Textfield::IsViewsTextfieldEnabled())
    198     set_id(VIEW_ID_OMNIBOX);
    199 
    200   const int kOmniboxBorderImages[] = IMAGE_GRID(IDR_OMNIBOX_BORDER);
    201   const int kOmniboxPopupImages[] = IMAGE_GRID(IDR_OMNIBOX_POPUP_BORDER);
    202   background_border_painter_.reset(
    203       views::Painter::CreateImageGridPainter(
    204           is_popup_mode_ ? kOmniboxPopupImages : kOmniboxBorderImages));
    205 #if defined(OS_CHROMEOS)
    206   if (!is_popup_mode_) {
    207     const int kOmniboxFillingImages[] = IMAGE_GRID(IDR_OMNIBOX_FILLING);
    208     background_filling_painter_.reset(
    209         views::Painter::CreateImageGridPainter(kOmniboxFillingImages));
    210   }
    211 #endif
    212 
    213   edit_bookmarks_enabled_.Init(
    214       prefs::kEditBookmarksEnabled,
    215       profile_->GetPrefs(),
    216       base::Bind(&LocationBarView::Update,
    217                  base::Unretained(this),
    218                  static_cast<content::WebContents*>(NULL)));
    219 
    220   if (browser_)
    221     browser_->search_model()->AddObserver(this);
    222 }
    223 
    224 LocationBarView::~LocationBarView() {
    225   if (template_url_service_)
    226     template_url_service_->RemoveObserver(this);
    227   if (browser_)
    228     browser_->search_model()->RemoveObserver(this);
    229 }
    230 
    231 // static
    232 void LocationBarView::InitTouchableLocationBarChildView(views::View* view) {
    233   int horizontal_padding = GetBuiltInHorizontalPaddingForChildViews();
    234   if (horizontal_padding != 0) {
    235     view->set_border(views::Border::CreateEmptyBorder(
    236         3, horizontal_padding, 3, horizontal_padding));
    237   }
    238 }
    239 
    240 void LocationBarView::Init() {
    241   // We need to be in a Widget, otherwise GetNativeTheme() may change and we're
    242   // not prepared for that.
    243   DCHECK(GetWidget());
    244 
    245   location_icon_view_ = new LocationIconView(this);
    246   location_icon_view_->set_drag_controller(this);
    247   AddChildView(location_icon_view_);
    248 
    249   // Determine the main font.
    250   gfx::FontList font_list = ResourceBundle::GetSharedInstance().GetFontList(
    251       ResourceBundle::BaseFont);
    252   const int current_font_size = font_list.GetFontSize();
    253   const int desired_font_size = browser_defaults::kOmniboxFontPixelSize;
    254   if (current_font_size < desired_font_size)
    255     font_list = font_list.DeriveFontListWithSize(desired_font_size);
    256   // Shrink large fonts to make them fit.
    257   // TODO(pkasting): Stretch the location bar instead in this case.
    258   int location_height = GetInternalHeight(true);
    259   int font_y_offset;
    260   CalculateFontAndOffsetForHeight(location_height, &font_list, &font_y_offset);
    261   const gfx::Font& font = font_list.GetPrimaryFont();
    262 
    263   // Determine the font for use inside the bubbles.
    264   gfx::FontList bubble_font_list(font_list);
    265   int bubble_font_y_offset;
    266   // The bubble background images have 1 px thick edges, which we don't want to
    267   // overlap.
    268   const int kBubbleInteriorVerticalPadding = 1;
    269   CalculateFontAndOffsetForHeight(
    270       location_height - ((kBubblePadding + kBubbleInteriorVerticalPadding) * 2),
    271       &bubble_font_list, &bubble_font_y_offset);
    272   bubble_font_y_offset += kBubbleInteriorVerticalPadding;
    273   const gfx::Font& bubble_font = font_list.GetPrimaryFont();
    274 
    275   const SkColor background_color =
    276       GetColor(ToolbarModel::NONE, LocationBarView::BACKGROUND);
    277   ev_bubble_view_ = new EVBubbleView(
    278       bubble_font, bubble_font_y_offset,
    279       GetColor(ToolbarModel::EV_SECURE, SECURITY_TEXT), background_color, this);
    280   ev_bubble_view_->set_drag_controller(this);
    281   AddChildView(ev_bubble_view_);
    282 
    283   // Initialize the Omnibox view.
    284   location_entry_.reset(CreateOmniboxView(this, model_, profile_,
    285       command_updater_, is_popup_mode_, this, font_list, font_y_offset));
    286   SetLocationEntryFocusable(true);
    287   location_entry_view_ = location_entry_->AddToView(this);
    288 
    289   // Initialize the inline autocomplete view which is visible only when IME is
    290   // turned on.  Use the same font with the omnibox and highlighted background.
    291   ime_inline_autocomplete_view_ = new views::Label(string16(), font);
    292   {
    293     // views::Label (|ime_inline_autocomplete_view_|) supports only gfx::Font
    294     // and ignores the rest of fonts but the first in |font_list| while
    295     // views::Textfield (|location_entry_view_|) supports gfx::FontList and
    296     // layouts text based on all fonts in the list.  Thus the font height and
    297     // baseline can be different between them.  We add padding to align them
    298     // on the same baseline.
    299     // TODO(yukishiino): Remove this hack once views::Label supports
    300     // gfx::FontList.
    301     const int baseline_diff = location_entry_view_->GetBaseline() -
    302         ime_inline_autocomplete_view_->GetBaseline();
    303     ime_inline_autocomplete_view_->set_border(
    304         views::Border::CreateEmptyBorder(
    305             font_y_offset + baseline_diff, 0, 0, 0));
    306   }
    307   ime_inline_autocomplete_view_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
    308   ime_inline_autocomplete_view_->SetAutoColorReadabilityEnabled(false);
    309   ime_inline_autocomplete_view_->set_background(
    310       views::Background::CreateSolidBackground(GetNativeTheme()->GetSystemColor(
    311           ui::NativeTheme::kColorId_TextfieldSelectionBackgroundFocused)));
    312   ime_inline_autocomplete_view_->SetEnabledColor(
    313       GetNativeTheme()->GetSystemColor(
    314           ui::NativeTheme::kColorId_TextfieldSelectionColor));
    315   ime_inline_autocomplete_view_->SetVisible(false);
    316   AddChildView(ime_inline_autocomplete_view_);
    317 
    318   const SkColor text_color = GetColor(ToolbarModel::NONE, TEXT);
    319   selected_keyword_view_ = new SelectedKeywordView(
    320       bubble_font, bubble_font_y_offset, text_color, background_color,
    321       profile_);
    322   AddChildView(selected_keyword_view_);
    323 
    324   suggested_text_view_ = new views::Label(string16(), font);
    325   suggested_text_view_->set_border(
    326       views::Border::CreateEmptyBorder(font_y_offset, 0, 0, 0));
    327   suggested_text_view_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
    328   suggested_text_view_->SetAutoColorReadabilityEnabled(false);
    329   suggested_text_view_->SetEnabledColor(GetColor(
    330       ToolbarModel::NONE, LocationBarView::DEEMPHASIZED_TEXT));
    331   suggested_text_view_->SetVisible(false);
    332   AddChildView(suggested_text_view_);
    333 
    334   keyword_hint_view_ = new KeywordHintView(
    335       profile_, font, font_y_offset,
    336       GetColor(ToolbarModel::NONE, LocationBarView::DEEMPHASIZED_TEXT),
    337       background_color);
    338   AddChildView(keyword_hint_view_);
    339 
    340   mic_search_view_ = new views::ImageButton(this);
    341   mic_search_view_->set_id(VIEW_ID_MIC_SEARCH_BUTTON);
    342   mic_search_view_->set_accessibility_focusable(true);
    343   mic_search_view_->SetTooltipText(
    344       l10n_util::GetStringUTF16(IDS_TOOLTIP_MIC_SEARCH));
    345   mic_search_view_->SetImage(
    346       views::Button::STATE_NORMAL,
    347       ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
    348           IDR_OMNIBOX_MIC_SEARCH));
    349   mic_search_view_->SetImageAlignment(views::ImageButton::ALIGN_CENTER,
    350                                       views::ImageButton::ALIGN_MIDDLE);
    351   mic_search_view_->SetVisible(false);
    352   InitTouchableLocationBarChildView(mic_search_view_);
    353   AddChildView(mic_search_view_);
    354 
    355   for (int i = 0; i < CONTENT_SETTINGS_NUM_TYPES; ++i) {
    356     ContentSettingImageView* content_blocked_view =
    357         new ContentSettingImageView(static_cast<ContentSettingsType>(i), this,
    358                                     bubble_font, bubble_font_y_offset,
    359                                     text_color, background_color);
    360     content_setting_views_.push_back(content_blocked_view);
    361     content_blocked_view->SetVisible(false);
    362     AddChildView(content_blocked_view);
    363   }
    364 
    365   generated_credit_card_view_ = new GeneratedCreditCardView(model_, delegate_);
    366   AddChildView(generated_credit_card_view_);
    367 
    368   zoom_view_ = new ZoomView(model_, delegate_);
    369   zoom_view_->set_id(VIEW_ID_ZOOM_BUTTON);
    370   AddChildView(zoom_view_);
    371 
    372   open_pdf_in_reader_view_ = new OpenPDFInReaderView(this);
    373   AddChildView(open_pdf_in_reader_view_);
    374 
    375   script_bubble_icon_view_ = new ScriptBubbleIconView(delegate());
    376   script_bubble_icon_view_->SetVisible(false);
    377   AddChildView(script_bubble_icon_view_);
    378 
    379   star_view_ = new StarView(command_updater_);
    380   star_view_->SetVisible(false);
    381   AddChildView(star_view_);
    382 
    383   registrar_.Add(this,
    384                  chrome::NOTIFICATION_EXTENSION_LOCATION_BAR_UPDATED,
    385                  content::Source<Profile>(profile_));
    386 
    387   // Initialize the location entry. We do this to avoid a black flash which is
    388   // visible when the location entry has just been initialized.
    389   Update(NULL);
    390 
    391   OnChanged();
    392 }
    393 
    394 bool LocationBarView::IsInitialized() const {
    395   return location_entry_view_ != NULL;
    396 }
    397 
    398 SkColor LocationBarView::GetColor(ToolbarModel::SecurityLevel security_level,
    399                                   ColorKind kind) const {
    400   const ui::NativeTheme* native_theme = GetNativeTheme();
    401   switch (kind) {
    402     case BACKGROUND:
    403 #if defined(OS_CHROMEOS)
    404       // Chrome OS requires a transparent omnibox background color.
    405       return SkColorSetARGB(0, 255, 255, 255);
    406 #else
    407       return native_theme->GetSystemColor(
    408           ui::NativeTheme::kColorId_TextfieldDefaultBackground);
    409 #endif
    410 
    411     case TEXT:
    412       return native_theme->GetSystemColor(
    413           ui::NativeTheme::kColorId_TextfieldDefaultColor);
    414 
    415     case SELECTED_TEXT:
    416       return native_theme->GetSystemColor(
    417           ui::NativeTheme::kColorId_TextfieldSelectionColor);
    418 
    419     case DEEMPHASIZED_TEXT:
    420       return color_utils::AlphaBlend(
    421           GetColor(security_level, TEXT),
    422           GetColor(security_level, BACKGROUND),
    423           128);
    424 
    425     case SECURITY_TEXT: {
    426       SkColor color;
    427       switch (security_level) {
    428         case ToolbarModel::EV_SECURE:
    429         case ToolbarModel::SECURE:
    430           color = SkColorSetRGB(7, 149, 0);
    431           break;
    432 
    433         case ToolbarModel::SECURITY_WARNING:
    434         case ToolbarModel::SECURITY_POLICY_WARNING:
    435           return GetColor(security_level, DEEMPHASIZED_TEXT);
    436           break;
    437 
    438         case ToolbarModel::SECURITY_ERROR:
    439           color = SkColorSetRGB(162, 0, 0);
    440           break;
    441 
    442         default:
    443           NOTREACHED();
    444           return GetColor(security_level, TEXT);
    445       }
    446       return color_utils::GetReadableColor(
    447           color, GetColor(security_level, BACKGROUND));
    448     }
    449 
    450     default:
    451       NOTREACHED();
    452       return GetColor(security_level, TEXT);
    453   }
    454 }
    455 
    456 void LocationBarView::GetOmniboxPopupPositioningInfo(
    457     gfx::Point* top_left_screen_coord,
    458     int* popup_width,
    459     int* left_margin,
    460     int* right_margin) {
    461   // Because the popup might appear atop the attached bookmark bar, there won't
    462   // necessarily be a client edge separating it from the rest of the toolbar.
    463   // Therefore we position the popup high enough so it can draw its own client
    464   // edge at the top, in the same place the toolbar would normally draw the
    465   // client edge.
    466   *top_left_screen_coord = gfx::Point(
    467       0,
    468       parent()->height() - views::NonClientFrameView::kClientEdgeThickness);
    469   views::View::ConvertPointToScreen(parent(), top_left_screen_coord);
    470   *popup_width = parent()->width();
    471 
    472   gfx::Rect location_bar_bounds(bounds());
    473   location_bar_bounds.Inset(kNormalEdgeThickness, 0);
    474   *left_margin = location_bar_bounds.x();
    475   *right_margin = *popup_width - location_bar_bounds.right();
    476 }
    477 
    478 // static
    479 int LocationBarView::GetItemPadding() {
    480   const int kTouchItemPadding = 8;
    481   if (ui::GetDisplayLayout() == ui::LAYOUT_TOUCH)
    482     return kTouchItemPadding;
    483 
    484   const int kDesktopScriptBadgeItemPadding = 9;
    485   const int kDesktopItemPadding = 3;
    486   return extensions::FeatureSwitch::script_badges()->IsEnabled() ?
    487       kDesktopScriptBadgeItemPadding : kDesktopItemPadding;
    488 }
    489 
    490 // DropdownBarHostDelegate
    491 void LocationBarView::SetFocusAndSelection(bool select_all) {
    492   FocusLocation(select_all);
    493 }
    494 
    495 void LocationBarView::SetAnimationOffset(int offset) {
    496   animation_offset_ = offset;
    497 }
    498 
    499 void LocationBarView::Update(const WebContents* tab_for_state_restoring) {
    500   mic_search_view_->SetVisible(
    501       !model_->GetInputInProgress() && browser_ &&
    502       browser_->search_model()->voice_search_supported());
    503   RefreshContentSettingViews();
    504   generated_credit_card_view_->Update();
    505   ZoomBubbleView::CloseBubble();
    506   RefreshZoomView();
    507   RefreshPageActionViews();
    508   RefreshScriptBubble();
    509   open_pdf_in_reader_view_->Update(
    510       model_->GetInputInProgress() ? NULL : GetWebContents());
    511 
    512   bool star_enabled =
    513       browser_defaults::bookmarks_enabled && !is_popup_mode_ && star_view_ &&
    514       !model_->GetInputInProgress() && edit_bookmarks_enabled_.GetValue();
    515 
    516   command_updater_->UpdateCommandEnabled(IDC_BOOKMARK_PAGE, star_enabled);
    517   command_updater_->UpdateCommandEnabled(IDC_BOOKMARK_PAGE_FROM_STAR,
    518                                          star_enabled);
    519   if (star_view_)
    520     star_view_->SetVisible(star_enabled);
    521 
    522   location_entry_->Update(tab_for_state_restoring);
    523 
    524   OnChanged();
    525 }
    526 
    527 void LocationBarView::UpdateContentSettingsIcons() {
    528   RefreshContentSettingViews();
    529 
    530   Layout();
    531   SchedulePaint();
    532 }
    533 
    534 void LocationBarView::UpdatePageActions() {
    535   size_t count_before = page_action_views_.size();
    536   RefreshPageActionViews();
    537   RefreshScriptBubble();
    538   if (page_action_views_.size() != count_before) {
    539     content::NotificationService::current()->Notify(
    540         chrome::NOTIFICATION_EXTENSION_PAGE_ACTION_COUNT_CHANGED,
    541         content::Source<LocationBar>(this),
    542         content::NotificationService::NoDetails());
    543   }
    544 
    545   Layout();
    546   SchedulePaint();
    547 }
    548 
    549 void LocationBarView::InvalidatePageActions() {
    550   size_t count_before = page_action_views_.size();
    551   DeletePageActionViews();
    552   if (page_action_views_.size() != count_before) {
    553     content::NotificationService::current()->Notify(
    554         chrome::NOTIFICATION_EXTENSION_PAGE_ACTION_COUNT_CHANGED,
    555         content::Source<LocationBar>(this),
    556         content::NotificationService::NoDetails());
    557   }
    558 }
    559 
    560 void LocationBarView::UpdateOpenPDFInReaderPrompt() {
    561   open_pdf_in_reader_view_->Update(
    562       model_->GetInputInProgress() ? NULL : GetWebContents());
    563   Layout();
    564   SchedulePaint();
    565 }
    566 
    567 void LocationBarView::UpdateGeneratedCreditCardView() {
    568   generated_credit_card_view_->Update();
    569   Layout();
    570   SchedulePaint();
    571 }
    572 
    573 void LocationBarView::OnFocus() {
    574   // Focus the view widget first which implements accessibility for
    575   // Chrome OS.  It is noop on Win. This should be removed once
    576   // Chrome OS migrates to aura, which uses Views' textfield that receives
    577   // focus. See crbug.com/106428.
    578   NotifyAccessibilityEvent(ui::AccessibilityTypes::EVENT_FOCUS, false);
    579 
    580   // Then focus the native location view which implements accessibility for
    581   // Windows.
    582   location_entry_->SetFocus();
    583 }
    584 
    585 void LocationBarView::SetPreviewEnabledPageAction(ExtensionAction* page_action,
    586                                                   bool preview_enabled) {
    587   if (is_popup_mode_)
    588     return;
    589 
    590   DCHECK(page_action);
    591   WebContents* contents = delegate_->GetWebContents();
    592 
    593   RefreshPageActionViews();
    594   PageActionWithBadgeView* page_action_view =
    595       static_cast<PageActionWithBadgeView*>(GetPageActionView(page_action));
    596   DCHECK(page_action_view);
    597   if (!page_action_view)
    598     return;
    599 
    600   page_action_view->image_view()->set_preview_enabled(preview_enabled);
    601   page_action_view->UpdateVisibility(contents, model_->GetURL());
    602   Layout();
    603   SchedulePaint();
    604 }
    605 
    606 views::View* LocationBarView::GetPageActionView(ExtensionAction *page_action) {
    607   DCHECK(page_action);
    608   for (PageActionViews::const_iterator i(page_action_views_.begin());
    609        i != page_action_views_.end(); ++i) {
    610     if ((*i)->image_view()->page_action() == page_action)
    611       return *i;
    612   }
    613   return NULL;
    614 }
    615 
    616 void LocationBarView::SetStarToggled(bool on) {
    617   if (star_view_)
    618     star_view_->SetToggled(on);
    619 }
    620 
    621 void LocationBarView::ShowBookmarkPrompt() {
    622   if (star_view_ && star_view_->visible())
    623     BookmarkPromptView::ShowPrompt(star_view_, profile_->GetPrefs());
    624 }
    625 
    626 void LocationBarView::ZoomChangedForActiveTab(bool can_show_bubble) {
    627   DCHECK(zoom_view_);
    628   RefreshZoomView();
    629 
    630   Layout();
    631   SchedulePaint();
    632 
    633   if (can_show_bubble && zoom_view_->visible() && delegate_->GetWebContents())
    634     ZoomBubbleView::ShowBubble(delegate_->GetWebContents(), true);
    635 }
    636 
    637 void LocationBarView::RefreshZoomView() {
    638   DCHECK(zoom_view_);
    639   WebContents* web_contents = GetWebContents();
    640   if (!web_contents)
    641     return;
    642 
    643   ZoomController* zoom_controller =
    644       ZoomController::FromWebContents(web_contents);
    645   zoom_view_->Update(zoom_controller);
    646 }
    647 
    648 gfx::Point LocationBarView::GetLocationEntryOrigin() const {
    649   gfx::Point origin(location_entry_view_->bounds().origin());
    650   // If the UI layout is RTL, the coordinate system is not transformed and
    651   // therefore we need to adjust the X coordinate so that bubble appears on the
    652   // right hand side of the location bar.
    653   if (base::i18n::IsRTL())
    654     origin.set_x(width() - origin.x());
    655   views::View::ConvertPointToScreen(this, &origin);
    656   return origin;
    657 }
    658 
    659 void LocationBarView::SetImeInlineAutocompletion(const string16& text) {
    660   ime_inline_autocomplete_view_->SetText(text);
    661   ime_inline_autocomplete_view_->SetVisible(!text.empty());
    662 }
    663 
    664 void LocationBarView::SetGrayTextAutocompletion(const string16& text) {
    665   if (suggested_text_view_->text() != text) {
    666     suggested_text_view_->SetText(text);
    667     suggested_text_view_->SetVisible(!text.empty());
    668     Layout();
    669     SchedulePaint();
    670   }
    671 }
    672 
    673 string16 LocationBarView::GetGrayTextAutocompletion() const {
    674   return HasValidSuggestText() ? suggested_text_view_->text() : string16();
    675 }
    676 
    677 void LocationBarView::SetLocationEntryFocusable(bool focusable) {
    678   OmniboxViewViews* omnibox_views = GetOmniboxViewViews(location_entry_.get());
    679   if (omnibox_views)
    680     omnibox_views->set_focusable(focusable);
    681   else
    682     set_focusable(focusable);
    683 }
    684 
    685 bool LocationBarView::IsLocationEntryFocusableInRootView() const {
    686   OmniboxViewViews* omnibox_views = GetOmniboxViewViews(location_entry_.get());
    687   return omnibox_views ? omnibox_views->IsFocusable() : View::IsFocusable();
    688 }
    689 
    690 gfx::Size LocationBarView::GetPreferredSize() {
    691   return background_border_painter_->GetMinimumSize();
    692 }
    693 
    694 void LocationBarView::Layout() {
    695   if (!location_entry_.get())
    696     return;
    697 
    698   selected_keyword_view_->SetVisible(false);
    699   location_icon_view_->SetVisible(false);
    700   ev_bubble_view_->SetVisible(false);
    701   keyword_hint_view_->SetVisible(false);
    702 
    703   const int item_padding = GetItemPadding();
    704   // The native edit has 1 px of whitespace inside it before the text when the
    705   // text is not scrolled off the leading edge.  The views textfield has 1 px of
    706   // whitespace before the text in the RTL case only.
    707   const int kEditLeadingInternalSpace =
    708       (base::i18n::IsRTL() || GetOmniboxViewWin(location_entry_.get())) ? 1 : 0;
    709   LocationBarLayout leading_decorations(
    710       LocationBarLayout::LEFT_EDGE, item_padding - kEditLeadingInternalSpace);
    711   LocationBarLayout trailing_decorations(LocationBarLayout::RIGHT_EDGE,
    712                                          item_padding);
    713 
    714   const string16 keyword(location_entry_->model()->keyword());
    715   const bool is_keyword_hint(location_entry_->model()->is_keyword_hint());
    716   const int bubble_location_y = vertical_edge_thickness() + kBubblePadding;
    717   // In some cases (e.g. fullscreen mode) we may have 0 height.  We still want
    718   // to position our child views in this case, because other things may be
    719   // positioned relative to them (e.g. the "bookmark added" bubble if the user
    720   // hits ctrl-d).
    721   const int location_height = GetInternalHeight(false);
    722   const int bubble_height = std::max(location_height - (kBubblePadding * 2), 0);
    723   if (!keyword.empty() && !is_keyword_hint) {
    724     leading_decorations.AddDecoration(bubble_location_y, bubble_height, true, 0,
    725                                       kBubblePadding, item_padding, 0,
    726                                       selected_keyword_view_);
    727     if (selected_keyword_view_->keyword() != keyword) {
    728       selected_keyword_view_->SetKeyword(keyword);
    729       const TemplateURL* template_url =
    730           TemplateURLServiceFactory::GetForProfile(profile_)->
    731           GetTemplateURLForKeyword(keyword);
    732       if (template_url && template_url->IsExtensionKeyword()) {
    733         gfx::Image image = extensions::OmniboxAPI::Get(profile_)->
    734             GetOmniboxIcon(template_url->GetExtensionId());
    735         selected_keyword_view_->SetImage(image.AsImageSkia());
    736         selected_keyword_view_->set_is_extension_icon(true);
    737       } else {
    738         selected_keyword_view_->SetImage(
    739             *(GetThemeProvider()->GetImageSkiaNamed(IDR_OMNIBOX_SEARCH)));
    740         selected_keyword_view_->set_is_extension_icon(false);
    741       }
    742     }
    743   } else if (model_->GetSecurityLevel(false) == ToolbarModel::EV_SECURE) {
    744     ev_bubble_view_->SetLabel(model_->GetEVCertName());
    745     // The largest fraction of the omnibox that can be taken by the EV bubble.
    746     const double kMaxBubbleFraction = 0.5;
    747     leading_decorations.AddDecoration(bubble_location_y, bubble_height, false,
    748                                       kMaxBubbleFraction, kBubblePadding,
    749                                       item_padding, 0, ev_bubble_view_);
    750   } else {
    751     leading_decorations.AddDecoration(
    752         vertical_edge_thickness(), location_height,
    753         GetBuiltInHorizontalPaddingForChildViews(),
    754         location_icon_view_);
    755   }
    756 
    757   if (star_view_ && star_view_->visible()) {
    758     trailing_decorations.AddDecoration(
    759         vertical_edge_thickness(), location_height,
    760         GetBuiltInHorizontalPaddingForChildViews(), star_view_);
    761   }
    762   if (script_bubble_icon_view_ && script_bubble_icon_view_->visible()) {
    763     trailing_decorations.AddDecoration(
    764         vertical_edge_thickness(), location_height,
    765         GetBuiltInHorizontalPaddingForChildViews(),
    766         script_bubble_icon_view_);
    767   }
    768   if (open_pdf_in_reader_view_ && open_pdf_in_reader_view_->visible()) {
    769     trailing_decorations.AddDecoration(
    770         vertical_edge_thickness(), location_height,
    771         GetBuiltInHorizontalPaddingForChildViews(),
    772         open_pdf_in_reader_view_);
    773   }
    774   for (PageActionViews::const_iterator i(page_action_views_.begin());
    775        i != page_action_views_.end(); ++i) {
    776     if ((*i)->visible()) {
    777       trailing_decorations.AddDecoration(
    778           vertical_edge_thickness(), location_height,
    779           GetBuiltInHorizontalPaddingForChildViews(), (*i));
    780     }
    781   }
    782   if (zoom_view_->visible()) {
    783     trailing_decorations.AddDecoration(vertical_edge_thickness(),
    784                                        location_height, 0, zoom_view_);
    785   }
    786   for (ContentSettingViews::const_reverse_iterator i(
    787            content_setting_views_.rbegin()); i != content_setting_views_.rend();
    788        ++i) {
    789     if ((*i)->visible()) {
    790       trailing_decorations.AddDecoration(
    791           bubble_location_y, bubble_height, false, 0, item_padding,
    792           item_padding, GetBuiltInHorizontalPaddingForChildViews(), (*i));
    793     }
    794   }
    795   if (generated_credit_card_view_->visible()) {
    796     trailing_decorations.AddDecoration(vertical_edge_thickness(),
    797                                        location_height, 0,
    798                                        generated_credit_card_view_);
    799   }
    800   if (mic_search_view_->visible()) {
    801     trailing_decorations.AddDecoration(vertical_edge_thickness(),
    802                                        location_height, 0, mic_search_view_);
    803   }
    804   // Because IMEs may eat the tab key, we don't show "press tab to search" while
    805   // IME composition is in progress.
    806   if (!keyword.empty() && is_keyword_hint &&
    807       !location_entry_->IsImeComposing()) {
    808     trailing_decorations.AddDecoration(vertical_edge_thickness(),
    809                                        location_height, true, 0, item_padding,
    810                                        item_padding, 0, keyword_hint_view_);
    811     if (keyword_hint_view_->keyword() != keyword)
    812       keyword_hint_view_->SetKeyword(keyword);
    813   }
    814 
    815   // Perform layout.
    816   const int horizontal_edge_thickness = GetHorizontalEdgeThickness();
    817   int full_width = width() - 2 * horizontal_edge_thickness;
    818   int entry_width = full_width;
    819   leading_decorations.LayoutPass1(&entry_width);
    820   trailing_decorations.LayoutPass1(&entry_width);
    821   leading_decorations.LayoutPass2(&entry_width);
    822   trailing_decorations.LayoutPass2(&entry_width);
    823 
    824   int location_needed_width = location_entry_->TextWidth();
    825   int available_width = entry_width - location_needed_width;
    826   // The bounds must be wide enough for all the decorations to fit.
    827   gfx::Rect location_bounds(
    828       horizontal_edge_thickness, vertical_edge_thickness(),
    829       std::max(full_width, full_width - entry_width), location_height);
    830   leading_decorations.LayoutPass3(&location_bounds, &available_width);
    831   trailing_decorations.LayoutPass3(&location_bounds, &available_width);
    832 
    833   // Layout out the suggested text view right aligned to the location
    834   // entry. Only show the suggested text if we can fit the text from one
    835   // character before the end of the selection to the end of the text and the
    836   // suggested text. If we can't it means either the suggested text is too big,
    837   // or the user has scrolled.
    838 
    839   // TODO(sky): We could potentially adjust this to take into account suggested
    840   // text to force using minimum size if necessary, but currently the chance of
    841   // showing keyword hints and suggested text is minimal and we're not confident
    842   // this is the right approach for suggested text.
    843 
    844   OmniboxViewViews* omnibox_views =
    845       GetOmniboxViewViews(location_entry_.get());
    846   int omnibox_views_margin = 0;
    847   if (suggested_text_view_->visible()) {
    848     // We do not display the suggested text when it contains a mix of RTL and
    849     // LTR characters since this could mean the suggestion should be displayed
    850     // in the middle of the string.
    851     base::i18n::TextDirection text_direction =
    852         base::i18n::GetStringDirection(location_entry_->GetText());
    853     if (text_direction !=
    854         base::i18n::GetStringDirection(suggested_text_view_->text()))
    855       text_direction = base::i18n::UNKNOWN_DIRECTION;
    856 
    857     // TODO(sky): need to layout when the user changes caret position.
    858     gfx::Size suggested_text_size(suggested_text_view_->GetPreferredSize());
    859     if (suggested_text_size.width() > available_width ||
    860         text_direction == base::i18n::UNKNOWN_DIRECTION) {
    861       // Hide the suggested text if the user has scrolled or we can't fit all
    862       // the suggested text, or we have a mix of RTL and LTR characters.
    863       suggested_text_view_->SetBounds(0, 0, 0, 0);
    864     } else {
    865       location_needed_width =
    866           std::min(location_needed_width,
    867                    location_bounds.width() - suggested_text_size.width());
    868       gfx::Rect suggested_text_bounds(location_bounds.origin(),
    869                                       suggested_text_size);
    870       // TODO(sky): figure out why this needs the -1.
    871       suggested_text_bounds.Offset(location_needed_width - 1, 0);
    872       // For non-views the omnibox needs to be shrunk so that the suggest text
    873       // is visible.
    874       if (!omnibox_views)
    875         location_bounds.set_width(location_needed_width);
    876 
    877       // We reverse the order of the location entry and suggested text if:
    878       // - Chrome is RTL but the text is fully LTR, or
    879       // - Chrome is LTR but the text is fully RTL.
    880       // This ensures the suggested text is correctly displayed to the right
    881       // (or left) of the user text.
    882       if (text_direction == (base::i18n::IsRTL() ?
    883           base::i18n::LEFT_TO_RIGHT : base::i18n::RIGHT_TO_LEFT)) {
    884         // TODO(sky): Figure out why we need the +1.
    885         suggested_text_bounds.set_x(location_bounds.x() + 1);
    886         if (omnibox_views) {
    887           // Use a margin to prevent the omnibox text from overlapping the
    888           // suggest text.
    889           omnibox_views_margin = suggested_text_bounds.width();
    890         } else {
    891           // Non-views doesn't support margins so move the omnibox over.
    892           location_bounds.set_x(
    893               location_bounds.x() + suggested_text_bounds.width());
    894         }
    895       }
    896       suggested_text_view_->SetBoundsRect(suggested_text_bounds);
    897     }
    898   }
    899 
    900   if (omnibox_views)
    901     omnibox_views->SetHorizontalMargins(0, omnibox_views_margin);
    902 
    903   // Layout |ime_inline_autocomplete_view_| next to the user input.
    904   if (ime_inline_autocomplete_view_->visible()) {
    905     int width =
    906         ime_inline_autocomplete_view_->font().GetStringWidth(
    907             ime_inline_autocomplete_view_->text()) +
    908         ime_inline_autocomplete_view_->GetInsets().width();
    909     // All the target languages (IMEs) are LTR, and we do not need to support
    910     // RTL so far.  In other words, no testable RTL environment so far.
    911     int x = location_needed_width;
    912     if (width > entry_width)
    913       x = 0;
    914     else if (location_needed_width + width > entry_width)
    915       x = entry_width - width;
    916     location_bounds.set_width(x);
    917     ime_inline_autocomplete_view_->SetBounds(
    918         location_bounds.right(), location_bounds.y(),
    919         std::min(width, entry_width),
    920         ime_inline_autocomplete_view_->GetPreferredSize().height());
    921   }
    922 
    923   location_entry_view_->SetBoundsRect(location_bounds);
    924 }
    925 
    926 void LocationBarView::OnPaint(gfx::Canvas* canvas) {
    927   View::OnPaint(canvas);
    928 
    929   // Fill the location bar background color behind the border.  Parts of the
    930   // border images are meant to rest atop the toolbar background and parts atop
    931   // the omnibox background, so we can't just blindly fill our entire bounds.
    932   const int horizontal_edge_thickness = GetHorizontalEdgeThickness();
    933   if (!background_filling_painter_) {
    934     gfx::Rect bounds(GetContentsBounds());
    935     bounds.Inset(horizontal_edge_thickness, vertical_edge_thickness());
    936     SkColor color(GetColor(ToolbarModel::NONE, BACKGROUND));
    937     if (is_popup_mode_) {
    938       canvas->FillRect(bounds, color);
    939     } else {
    940       SkPaint paint;
    941       paint.setStyle(SkPaint::kFill_Style);
    942       paint.setColor(color);
    943       const int kBorderCornerRadius = 2;
    944       canvas->DrawRoundRect(bounds, kBorderCornerRadius, paint);
    945     }
    946   }
    947 
    948   // Maximized popup windows don't draw the horizontal edges.  We implement this
    949   // by simply expanding the paint area outside the view by the edge thickness.
    950   gfx::Rect background_rect(GetContentsBounds());
    951   if (is_popup_mode_ && (horizontal_edge_thickness == 0))
    952     background_rect.Inset(-kPopupEdgeThickness, 0);
    953   views::Painter::PaintPainterAt(canvas, background_border_painter_.get(),
    954                                  background_rect);
    955   if (background_filling_painter_)
    956     background_filling_painter_->Paint(canvas, size());
    957 
    958   if (!is_popup_mode_)
    959     PaintPageActionBackgrounds(canvas);
    960 
    961   // For non-InstantExtendedAPI cases, if necessary, show focus rect.
    962   // Note: |Canvas::DrawFocusRect| paints a dashed rect with gray color.
    963   if (show_focus_rect_ && HasFocus()) {
    964     gfx::Rect r = location_entry_view_->bounds();
    965     // TODO(jamescook): Is this still needed?
    966     r.Inset(-1, 0);
    967 #if defined(OS_WIN)
    968     r.Inset(0, -1);
    969 #endif
    970     canvas->DrawFocusRect(r);
    971   }
    972 }
    973 
    974 void LocationBarView::SetShowFocusRect(bool show) {
    975   show_focus_rect_ = show;
    976   SchedulePaint();
    977 }
    978 
    979 void LocationBarView::SelectAll() {
    980   location_entry_->SelectAll(true);
    981 }
    982 
    983 #if defined(OS_WIN) && !defined(USE_AURA)
    984 bool LocationBarView::OnMousePressed(const ui::MouseEvent& event) {
    985   UINT msg;
    986   if (event.IsLeftMouseButton()) {
    987     msg = (event.flags() & ui::EF_IS_DOUBLE_CLICK) ?
    988         WM_LBUTTONDBLCLK : WM_LBUTTONDOWN;
    989   } else if (event.IsMiddleMouseButton()) {
    990     msg = (event.flags() & ui::EF_IS_DOUBLE_CLICK) ?
    991         WM_MBUTTONDBLCLK : WM_MBUTTONDOWN;
    992   } else if (event.IsRightMouseButton()) {
    993     msg = (event.flags() & ui::EF_IS_DOUBLE_CLICK) ?
    994         WM_RBUTTONDBLCLK : WM_RBUTTONDOWN;
    995   } else {
    996     NOTREACHED();
    997     return false;
    998   }
    999   OnMouseEvent(event, msg);
   1000   return true;
   1001 }
   1002 
   1003 bool LocationBarView::OnMouseDragged(const ui::MouseEvent& event) {
   1004   OnMouseEvent(event, WM_MOUSEMOVE);
   1005   return true;
   1006 }
   1007 
   1008 void LocationBarView::OnMouseReleased(const ui::MouseEvent& event) {
   1009   UINT msg;
   1010   if (event.IsLeftMouseButton()) {
   1011     msg = WM_LBUTTONUP;
   1012   } else if (event.IsMiddleMouseButton()) {
   1013     msg = WM_MBUTTONUP;
   1014   } else if (event.IsRightMouseButton()) {
   1015     msg = WM_RBUTTONUP;
   1016   } else {
   1017     NOTREACHED();
   1018     return;
   1019   }
   1020   OnMouseEvent(event, msg);
   1021 }
   1022 
   1023 void LocationBarView::OnMouseCaptureLost() {
   1024   OmniboxViewWin* omnibox_win = GetOmniboxViewWin(location_entry_.get());
   1025   if (omnibox_win)
   1026     omnibox_win->HandleExternalMsg(WM_CAPTURECHANGED, 0, CPoint());
   1027 }
   1028 #endif
   1029 
   1030 views::View* LocationBarView::generated_credit_card_view() {
   1031   return generated_credit_card_view_;
   1032 }
   1033 
   1034 void LocationBarView::OnAutocompleteAccept(
   1035     const GURL& url,
   1036     WindowOpenDisposition disposition,
   1037     content::PageTransition transition,
   1038     const GURL& alternate_nav_url) {
   1039   // WARNING: don't add an early return here. The calls after the if must
   1040   // happen.
   1041   if (url.is_valid()) {
   1042     location_input_ = UTF8ToUTF16(url.spec());
   1043     disposition_ = disposition;
   1044     transition_ = content::PageTransitionFromInt(
   1045         transition | content::PAGE_TRANSITION_FROM_ADDRESS_BAR);
   1046 
   1047     if (command_updater_) {
   1048       if (!alternate_nav_url.is_valid()) {
   1049         command_updater_->ExecuteCommand(IDC_OPEN_CURRENT_URL);
   1050       } else {
   1051         AlternateNavURLFetcher* fetcher =
   1052             new AlternateNavURLFetcher(alternate_nav_url);
   1053         // The AlternateNavURLFetcher will listen for the pending navigation
   1054         // notification that will be issued as a result of the "open URL." It
   1055         // will automatically install itself into that navigation controller.
   1056         command_updater_->ExecuteCommand(IDC_OPEN_CURRENT_URL);
   1057         if (fetcher->state() == AlternateNavURLFetcher::NOT_STARTED) {
   1058           // I'm not sure this should be reachable, but I'm not also sure enough
   1059           // that it shouldn't to stick in a NOTREACHED().  In any case, this is
   1060           // harmless.
   1061           delete fetcher;
   1062         } else {
   1063           // The navigation controller will delete the fetcher.
   1064         }
   1065       }
   1066     }
   1067   }
   1068 }
   1069 
   1070 void LocationBarView::OnChanged() {
   1071   location_icon_view_->SetImage(
   1072       GetThemeProvider()->GetImageSkiaNamed(location_entry_->GetIcon()));
   1073   location_icon_view_->ShowTooltip(!GetLocationEntry()->IsEditingOrEmpty());
   1074 
   1075   Layout();
   1076   SchedulePaint();
   1077 }
   1078 
   1079 void LocationBarView::OnSelectionBoundsChanged() {
   1080 }
   1081 
   1082 void LocationBarView::OnInputInProgress(bool in_progress) {
   1083   delegate_->OnInputInProgress(in_progress);
   1084 }
   1085 
   1086 void LocationBarView::OnKillFocus() {
   1087 }
   1088 
   1089 void LocationBarView::OnSetFocus() {
   1090   views::FocusManager* focus_manager = GetFocusManager();
   1091   if (!focus_manager) {
   1092     NOTREACHED();
   1093     return;
   1094   }
   1095   focus_manager->SetFocusedView(this);
   1096 }
   1097 
   1098 gfx::Image LocationBarView::GetFavicon() const {
   1099   return FaviconTabHelper::FromWebContents(
   1100       delegate_->GetWebContents())->GetFavicon();
   1101 }
   1102 
   1103 string16 LocationBarView::GetTitle() const {
   1104   return delegate_->GetWebContents()->GetTitle();
   1105 }
   1106 
   1107 InstantController* LocationBarView::GetInstant() {
   1108   return delegate_->GetInstant();
   1109 }
   1110 
   1111 WebContents* LocationBarView::GetWebContents() const {
   1112   return delegate_->GetWebContents();
   1113 }
   1114 
   1115 // static
   1116 int LocationBarView::GetBuiltInHorizontalPaddingForChildViews() {
   1117   return (ui::GetDisplayLayout() == ui::LAYOUT_TOUCH) ?
   1118       GetItemPadding() / 2 : 0;
   1119 }
   1120 
   1121 int LocationBarView::GetHorizontalEdgeThickness() const {
   1122   // In maximized popup mode, there isn't any edge.
   1123   return (is_popup_mode_ && browser_ && browser_->window() &&
   1124       browser_->window()->IsMaximized()) ? 0 : vertical_edge_thickness();
   1125 }
   1126 
   1127 void LocationBarView::RefreshContentSettingViews() {
   1128   for (ContentSettingViews::const_iterator i(content_setting_views_.begin());
   1129        i != content_setting_views_.end(); ++i) {
   1130     (*i)->Update(model_->GetInputInProgress() ? NULL : GetWebContents());
   1131   }
   1132 }
   1133 
   1134 void LocationBarView::DeletePageActionViews() {
   1135   for (PageActionViews::const_iterator i(page_action_views_.begin());
   1136        i != page_action_views_.end(); ++i)
   1137     RemoveChildView(*i);
   1138   STLDeleteElements(&page_action_views_);
   1139 }
   1140 
   1141 void LocationBarView::RefreshPageActionViews() {
   1142   if (is_popup_mode_)
   1143     return;
   1144 
   1145   // Remember the previous visibility of the page actions so that we can
   1146   // notify when this changes.
   1147   std::map<ExtensionAction*, bool> old_visibility;
   1148   for (PageActionViews::const_iterator i(page_action_views_.begin());
   1149        i != page_action_views_.end(); ++i) {
   1150     old_visibility[(*i)->image_view()->page_action()] = (*i)->visible();
   1151   }
   1152 
   1153   std::vector<ExtensionAction*> new_page_actions;
   1154 
   1155   WebContents* contents = delegate_->GetWebContents();
   1156   if (contents) {
   1157     extensions::TabHelper* extensions_tab_helper =
   1158         extensions::TabHelper::FromWebContents(contents);
   1159     extensions::LocationBarController* controller =
   1160         extensions_tab_helper->location_bar_controller();
   1161     new_page_actions = controller->GetCurrentActions();
   1162   }
   1163 
   1164   // On startup we sometimes haven't loaded any extensions. This makes sure
   1165   // we catch up when the extensions (and any page actions) load.
   1166   if (page_actions_ != new_page_actions) {
   1167     page_actions_.swap(new_page_actions);
   1168     DeletePageActionViews();  // Delete the old views (if any).
   1169 
   1170     page_action_views_.resize(page_actions_.size());
   1171     View* right_anchor = open_pdf_in_reader_view_;
   1172     if (!right_anchor)
   1173       right_anchor = star_view_;
   1174     if (!right_anchor)
   1175       right_anchor = script_bubble_icon_view_;
   1176     DCHECK(right_anchor);
   1177 
   1178     // Add the page actions in reverse order, so that the child views are
   1179     // inserted in left-to-right order for accessibility.
   1180     for (int i = page_actions_.size() - 1; i >= 0; --i) {
   1181       page_action_views_[i] = new PageActionWithBadgeView(
   1182           delegate_->CreatePageActionImageView(this, page_actions_[i]));
   1183       page_action_views_[i]->SetVisible(false);
   1184       AddChildViewAt(page_action_views_[i], GetIndexOf(right_anchor));
   1185     }
   1186   }
   1187 
   1188   if (!page_action_views_.empty() && contents) {
   1189     Browser* browser = chrome::FindBrowserWithWebContents(contents);
   1190     GURL url = browser->tab_strip_model()->GetActiveWebContents()->GetURL();
   1191 
   1192     for (PageActionViews::const_iterator i(page_action_views_.begin());
   1193          i != page_action_views_.end(); ++i) {
   1194       (*i)->UpdateVisibility(model_->GetInputInProgress() ? NULL : contents,
   1195                              url);
   1196 
   1197       // Check if the visibility of the action changed and notify if it did.
   1198       ExtensionAction* action = (*i)->image_view()->page_action();
   1199       if (old_visibility.find(action) == old_visibility.end() ||
   1200           old_visibility[action] != (*i)->visible()) {
   1201         content::NotificationService::current()->Notify(
   1202             chrome::NOTIFICATION_EXTENSION_PAGE_ACTION_VISIBILITY_CHANGED,
   1203             content::Source<ExtensionAction>(action),
   1204             content::Details<WebContents>(contents));
   1205       }
   1206     }
   1207   }
   1208 }
   1209 
   1210 size_t LocationBarView::ScriptBubbleScriptsRunning() {
   1211   WebContents* contents = delegate_->GetWebContents();
   1212   if (!contents)
   1213     return false;
   1214   extensions::TabHelper* extensions_tab_helper =
   1215       extensions::TabHelper::FromWebContents(contents);
   1216   if (!extensions_tab_helper)
   1217     return false;
   1218   extensions::ScriptBubbleController* script_bubble_controller =
   1219       extensions_tab_helper->script_bubble_controller();
   1220   if (!script_bubble_controller)
   1221     return false;
   1222   size_t script_count =
   1223       script_bubble_controller->extensions_running_scripts().size();
   1224   return script_count;
   1225 }
   1226 
   1227 void LocationBarView::RefreshScriptBubble() {
   1228   if (!script_bubble_icon_view_)
   1229     return;
   1230   size_t script_count = ScriptBubbleScriptsRunning();
   1231   script_bubble_icon_view_->SetVisible(script_count > 0);
   1232   if (script_count > 0)
   1233     script_bubble_icon_view_->SetScriptCount(script_count);
   1234 }
   1235 
   1236 #if defined(OS_WIN) && !defined(USE_AURA)
   1237 void LocationBarView::OnMouseEvent(const ui::MouseEvent& event, UINT msg) {
   1238   OmniboxViewWin* omnibox_win = GetOmniboxViewWin(location_entry_.get());
   1239   if (omnibox_win) {
   1240     UINT flags = event.native_event().wParam;
   1241     gfx::Point screen_point(event.location());
   1242     ConvertPointToScreen(this, &screen_point);
   1243     omnibox_win->HandleExternalMsg(msg, flags, screen_point.ToPOINT());
   1244   }
   1245 }
   1246 #endif
   1247 
   1248 void LocationBarView::ShowFirstRunBubbleInternal() {
   1249 #if !defined(OS_CHROMEOS)
   1250   // First run bubble doesn't make sense for Chrome OS.
   1251   Browser* browser = GetBrowserFromDelegate(delegate_);
   1252   if (!browser)
   1253     return; // Possible when browser is shutting down.
   1254 
   1255   FirstRunBubble::ShowBubble(browser, location_icon_view_);
   1256 #endif
   1257 }
   1258 
   1259 void LocationBarView::PaintPageActionBackgrounds(gfx::Canvas* canvas) {
   1260   WebContents* web_contents = GetWebContents();
   1261   // web_contents may be NULL while the browser is shutting down.
   1262   if (!web_contents)
   1263     return;
   1264 
   1265   const int32 tab_id = SessionID::IdForTab(web_contents);
   1266   const ToolbarModel::SecurityLevel security_level =
   1267       model_->GetSecurityLevel(false);
   1268   const SkColor text_color = GetColor(security_level, TEXT);
   1269   const SkColor background_color = GetColor(security_level, BACKGROUND);
   1270 
   1271   for (PageActionViews::const_iterator
   1272            page_action_view = page_action_views_.begin();
   1273        page_action_view != page_action_views_.end();
   1274        ++page_action_view) {
   1275     gfx::Rect bounds = (*page_action_view)->bounds();
   1276     int horizontal_padding =
   1277         GetItemPadding() - GetBuiltInHorizontalPaddingForChildViews();
   1278     // Make the bounding rectangle include the whole vertical range of the
   1279     // location bar, and the mid-point pixels between adjacent page actions.
   1280     //
   1281     // For odd horizontal_paddings, "horizontal_padding + 1" includes the
   1282     // mid-point between two page actions in the bounding rectangle.  For even
   1283     // paddings, the +1 is dropped, which is right since there is no pixel at
   1284     // the mid-point.
   1285     bounds.Inset(-(horizontal_padding + 1) / 2, 0);
   1286     location_bar_util::PaintExtensionActionBackground(
   1287         *(*page_action_view)->image_view()->page_action(),
   1288         tab_id, canvas, bounds, text_color, background_color);
   1289   }
   1290 }
   1291 
   1292 const char* LocationBarView::GetClassName() const {
   1293   return kViewClassName;
   1294 }
   1295 
   1296 bool LocationBarView::SkipDefaultKeyEventProcessing(const ui::KeyEvent& event) {
   1297 #if defined(OS_WIN)
   1298   if (views::FocusManager::IsTabTraversalKeyEvent(event)) {
   1299     if (location_entry_->model()->popup_model()->IsOpen()) {
   1300       // Return true so that the edit sees the tab and moves the selection.
   1301       return true;
   1302     }
   1303     if (keyword_hint_view_->visible() && !event.IsShiftDown()) {
   1304       // Return true so the edit gets the tab event and enters keyword mode.
   1305       return true;
   1306     }
   1307   }
   1308 
   1309 #if defined(USE_AURA)
   1310   NOTIMPLEMENTED();
   1311 #else
   1312   OmniboxViewWin* omnibox_win = GetOmniboxViewWin(location_entry_.get());
   1313   if (omnibox_win)
   1314     return omnibox_win->SkipDefaultKeyEventProcessing(event);
   1315 #endif  // USE_AURA
   1316 #endif  // OS_WIN
   1317 
   1318   // This method is not used for Linux ports. See FocusManager::OnKeyEvent() in
   1319   // src/ui/views/focus/focus_manager.cc for details.
   1320   return false;
   1321 }
   1322 
   1323 void LocationBarView::GetAccessibleState(ui::AccessibleViewState* state) {
   1324   if (!location_entry_)
   1325     return;
   1326 
   1327   state->role = ui::AccessibilityTypes::ROLE_LOCATION_BAR;
   1328   state->name = l10n_util::GetStringUTF16(IDS_ACCNAME_LOCATION);
   1329   state->value = location_entry_->GetText();
   1330 
   1331   string16::size_type entry_start;
   1332   string16::size_type entry_end;
   1333   location_entry_->GetSelectionBounds(&entry_start, &entry_end);
   1334   state->selection_start = entry_start;
   1335   state->selection_end = entry_end;
   1336 
   1337   if (is_popup_mode_) {
   1338     state->state |= ui::AccessibilityTypes::STATE_READONLY;
   1339   } else {
   1340     state->set_value_callback =
   1341         base::Bind(&LocationBarView::AccessibilitySetValue,
   1342                    weak_ptr_factory_.GetWeakPtr());
   1343   }
   1344 }
   1345 
   1346 bool LocationBarView::HasFocus() const {
   1347   return location_entry_->model()->has_focus();
   1348 }
   1349 
   1350 void LocationBarView::OnBoundsChanged(const gfx::Rect& previous_bounds) {
   1351   if (browser_ && browser_->instant_controller() && parent())
   1352     browser_->instant_controller()->SetOmniboxBounds(bounds());
   1353   OmniboxPopupView* popup = location_entry_->model()->popup_model()->view();
   1354   if (popup->IsOpen())
   1355     popup->UpdatePopupAppearance();
   1356 }
   1357 
   1358 void LocationBarView::ButtonPressed(views::Button* sender,
   1359                                     const ui::Event& event) {
   1360   DCHECK_EQ(mic_search_view_, sender);
   1361   command_updater_->ExecuteCommand(IDC_TOGGLE_SPEECH_INPUT);
   1362 }
   1363 
   1364 void LocationBarView::WriteDragDataForView(views::View* sender,
   1365                                            const gfx::Point& press_pt,
   1366                                            OSExchangeData* data) {
   1367   DCHECK_NE(GetDragOperationsForView(sender, press_pt),
   1368             ui::DragDropTypes::DRAG_NONE);
   1369 
   1370   WebContents* web_contents = GetWebContents();
   1371   FaviconTabHelper* favicon_tab_helper =
   1372       FaviconTabHelper::FromWebContents(web_contents);
   1373   gfx::ImageSkia favicon = favicon_tab_helper->GetFavicon().AsImageSkia();
   1374   button_drag_utils::SetURLAndDragImage(web_contents->GetURL(),
   1375                                         web_contents->GetTitle(),
   1376                                         favicon,
   1377                                         data,
   1378                                         sender->GetWidget());
   1379 }
   1380 
   1381 int LocationBarView::GetDragOperationsForView(views::View* sender,
   1382                                               const gfx::Point& p) {
   1383   DCHECK((sender == location_icon_view_) || (sender == ev_bubble_view_));
   1384   WebContents* web_contents = delegate_->GetWebContents();
   1385   return (web_contents && web_contents->GetURL().is_valid() &&
   1386           !GetLocationEntry()->IsEditingOrEmpty()) ?
   1387       (ui::DragDropTypes::DRAG_COPY | ui::DragDropTypes::DRAG_LINK) :
   1388       ui::DragDropTypes::DRAG_NONE;
   1389 }
   1390 
   1391 bool LocationBarView::CanStartDragForView(View* sender,
   1392                                           const gfx::Point& press_pt,
   1393                                           const gfx::Point& p) {
   1394   return true;
   1395 }
   1396 
   1397 ////////////////////////////////////////////////////////////////////////////////
   1398 // LocationBarView, LocationBar implementation:
   1399 
   1400 void LocationBarView::ShowFirstRunBubble() {
   1401   // Wait until search engines have loaded to show the first run bubble.
   1402   TemplateURLService* url_service =
   1403       TemplateURLServiceFactory::GetForProfile(profile_);
   1404   if (!url_service->loaded()) {
   1405     template_url_service_ = url_service;
   1406     template_url_service_->AddObserver(this);
   1407     template_url_service_->Load();
   1408     return;
   1409   }
   1410   ShowFirstRunBubbleInternal();
   1411 }
   1412 
   1413 string16 LocationBarView::GetInputString() const {
   1414   return location_input_;
   1415 }
   1416 
   1417 WindowOpenDisposition LocationBarView::GetWindowOpenDisposition() const {
   1418   return disposition_;
   1419 }
   1420 
   1421 content::PageTransition LocationBarView::GetPageTransition() const {
   1422   return transition_;
   1423 }
   1424 
   1425 void LocationBarView::AcceptInput() {
   1426   location_entry_->model()->AcceptInput(CURRENT_TAB, false);
   1427 }
   1428 
   1429 void LocationBarView::FocusLocation(bool select_all) {
   1430   location_entry_->SetFocus();
   1431   if (select_all)
   1432     location_entry_->SelectAll(true);
   1433 }
   1434 
   1435 void LocationBarView::FocusSearch() {
   1436   location_entry_->SetFocus();
   1437   location_entry_->SetForcedQuery();
   1438 }
   1439 
   1440 void LocationBarView::SaveStateToContents(WebContents* contents) {
   1441   location_entry_->SaveStateToTab(contents);
   1442 }
   1443 
   1444 void LocationBarView::Revert() {
   1445   location_entry_->RevertAll();
   1446 }
   1447 
   1448 const OmniboxView* LocationBarView::GetLocationEntry() const {
   1449   return location_entry_.get();
   1450 }
   1451 
   1452 OmniboxView* LocationBarView::GetLocationEntry() {
   1453   return location_entry_.get();
   1454 }
   1455 
   1456 LocationBarTesting* LocationBarView::GetLocationBarForTesting() {
   1457   return this;
   1458 }
   1459 
   1460 int LocationBarView::PageActionCount() {
   1461   return page_action_views_.size();
   1462 }
   1463 
   1464 int LocationBarView::PageActionVisibleCount() {
   1465   int result = 0;
   1466   for (size_t i = 0; i < page_action_views_.size(); i++) {
   1467     if (page_action_views_[i]->visible())
   1468       ++result;
   1469   }
   1470   return result;
   1471 }
   1472 
   1473 ExtensionAction* LocationBarView::GetPageAction(size_t index) {
   1474   if (index < page_action_views_.size())
   1475     return page_action_views_[index]->image_view()->page_action();
   1476 
   1477   NOTREACHED();
   1478   return NULL;
   1479 }
   1480 
   1481 ExtensionAction* LocationBarView::GetVisiblePageAction(size_t index) {
   1482   size_t current = 0;
   1483   for (size_t i = 0; i < page_action_views_.size(); ++i) {
   1484     if (page_action_views_[i]->visible()) {
   1485       if (current == index)
   1486         return page_action_views_[i]->image_view()->page_action();
   1487 
   1488       ++current;
   1489     }
   1490   }
   1491 
   1492   NOTREACHED();
   1493   return NULL;
   1494 }
   1495 
   1496 void LocationBarView::TestPageActionPressed(size_t index) {
   1497   size_t current = 0;
   1498   for (size_t i = 0; i < page_action_views_.size(); ++i) {
   1499     if (page_action_views_[i]->visible()) {
   1500       if (current == index) {
   1501         page_action_views_[i]->image_view()->ExecuteAction(
   1502             ExtensionPopup::SHOW);
   1503         return;
   1504       }
   1505       ++current;
   1506     }
   1507   }
   1508 
   1509   NOTREACHED();
   1510 }
   1511 
   1512 bool LocationBarView::GetBookmarkStarVisibility() {
   1513   DCHECK(star_view_);
   1514   return star_view_->visible();
   1515 }
   1516 
   1517 void LocationBarView::OnTemplateURLServiceChanged() {
   1518   template_url_service_->RemoveObserver(this);
   1519   template_url_service_ = NULL;
   1520   // If the browser is no longer active, let's not show the info bubble, as this
   1521   // would make the browser the active window again.
   1522   if (location_entry_view_ && location_entry_view_->GetWidget()->IsActive())
   1523     ShowFirstRunBubble();
   1524 }
   1525 
   1526 void LocationBarView::Observe(int type,
   1527                               const content::NotificationSource& source,
   1528                               const content::NotificationDetails& details) {
   1529   switch (type) {
   1530     case chrome::NOTIFICATION_EXTENSION_LOCATION_BAR_UPDATED: {
   1531       // Only update if the updated action box was for the active tab contents.
   1532       WebContents* target_tab = content::Details<WebContents>(details).ptr();
   1533       if (target_tab == GetWebContents())
   1534         UpdatePageActions();
   1535       break;
   1536     }
   1537 
   1538     default:
   1539       NOTREACHED() << "Unexpected notification.";
   1540   }
   1541 }
   1542 
   1543 void LocationBarView::ModelChanged(const SearchModel::State& old_state,
   1544                                    const SearchModel::State& new_state) {
   1545   const bool visible =
   1546       !model_->GetInputInProgress() && new_state.voice_search_supported;
   1547   if (mic_search_view_->visible() != visible) {
   1548     mic_search_view_->SetVisible(visible);
   1549     Layout();
   1550   }
   1551 }
   1552 
   1553 int LocationBarView::GetInternalHeight(bool use_preferred_size) {
   1554   int total_height =
   1555       use_preferred_size ? GetPreferredSize().height() : height();
   1556   return std::max(total_height - (vertical_edge_thickness() * 2), 0);
   1557 }
   1558 
   1559 bool LocationBarView::HasValidSuggestText() const {
   1560   return suggested_text_view_->visible() &&
   1561       !suggested_text_view_->size().IsEmpty();
   1562 }
   1563 
   1564 void LocationBarView::AccessibilitySetValue(const string16& new_value) {
   1565   location_entry_->SetUserText(new_value);
   1566 }
   1567