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