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