Give request-to-act badges a grey background, and increase spacing to make it fit.

chrome/browser/ui/gtk/location_bar_view_gtk.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/ui/gtk/location_bar_view_gtk.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 104 matching lines @@
 const int kFirstRunBubbleLeftSpacing = 4;
 
 // The padding around the top, bottom, and sides of the location bar hbox.
 // We don't want to edit control's text to be right against the edge,
 // as well the tab to search box and other widgets need to have the padding on
 // top and bottom to avoid drawing larger than the location bar space.
 const int kHboxBorder = 2;
 
 // Padding between the elements in the bar.
 const int kInnerPadding = 2;
-
-// Padding between the right of the star and the edge of the URL entry.
-const int kStarRightPadding = 2;
+const int kScriptBadgeInnerPadding = 9;
 
 // Colors used to draw the EV certificate rounded bubble.
 const GdkColor kEvSecureTextColor = GDK_COLOR_RGB(0x07, 0x95, 0x00);
 const GdkColor kEvSecureBackgroundColor = GDK_COLOR_RGB(0xef, 0xfc, 0xef);
 const GdkColor kEvSecureBorderColor = GDK_COLOR_RGB(0x90, 0xc3, 0x90);
 
 // Colors used to draw the Tab to Search rounded bubble.
 const GdkColor kKeywordBackgroundColor = GDK_COLOR_RGB(0xf0, 0xf4, 0xfa);
 const GdkColor kKeywordBorderColor = GDK_COLOR_RGB(0xcb, 0xde, 0xf7);
 
@@ skipping 19 matching lines @@
 const GdkColor kContentSettingBorderColor = GDK_COLOR_RGB(0xe9, 0xb9, 0x66);
 // Colors for the background gradient.
 const GdkColor kContentSettingTopColor = GDK_COLOR_RGB(0xff, 0xf8, 0xd4);
 const GdkColor kContentSettingBottomColor = GDK_COLOR_RGB(0xff, 0xe6, 0xaf);
 
 // Styling for gray button.
 const GdkColor kGrayBorderColor = GDK_COLOR_RGB(0xa0, 0xa0, 0xa0);
 const GdkColor kTopColorGray = GDK_COLOR_RGB(0xe5, 0xe5, 0xe5);
 const GdkColor kBottomColorGray = GDK_COLOR_RGB(0xd0, 0xd0, 0xd0);
 
+inline int InnerPadding() {
+  return extensions::switch_utils::AreScriptBadgesEnabled() ?
+      kScriptBadgeInnerPadding : kInnerPadding;
+}
+
 // If widget is visible, increment the int pointed to by count.
 // Suitible for use with gtk_container_foreach.
 void CountVisibleWidgets(GtkWidget* widget, gpointer count) {
   if (gtk_widget_get_visible(widget))
     *static_cast<int*>(count) += 1;
 }
 
 class ContentSettingImageViewGtk : public LocationBarViewGtk::PageToolViewGtk,
                                    public BubbleDelegateGtk {
  public:
@@ skipping 255 matching lines @@
   web_intents_hbox_.Destroy();
 }
 
 void LocationBarViewGtk::Init(bool popup_window_mode) {
   popup_window_mode_ = popup_window_mode;
 
   Profile* profile = browser_->profile();
   theme_service_ = GtkThemeService::GetFrom(profile);
 
   // Create the widget first, so we can pass it to the OmniboxViewGtk.
-  hbox_.Own(gtk_hbox_new(FALSE, kInnerPadding));
+  hbox_.Own(gtk_hbox_new(FALSE, InnerPadding()));
   gtk_container_set_border_width(GTK_CONTAINER(hbox_.get()), kHboxBorder);
   // We will paint for the alignment, to paint the background and border.
   gtk_widget_set_app_paintable(hbox_.get(), TRUE);
   // Redraw the whole location bar when it changes size (e.g., when toggling
   // the home button on/off.
   gtk_widget_set_redraw_on_allocate(hbox_.get(), TRUE);
 
   // Now initialize the OmniboxViewGtk.
   location_entry_.reset(new OmniboxViewGtk(this, toolbar_model_, browser_,
       command_updater_, popup_window_mode_, hbox_.get()));
   location_entry_->Init();
 
   g_signal_connect(hbox_.get(), "expose-event",
                    G_CALLBACK(&HandleExposeThunk), this);
 
   BuildSiteTypeArea();
 
   // Put |tab_to_search_box_|, |location_entry_|, and |tab_to_search_hint_| into
   // a sub hbox, so that we can make this part horizontally shrinkable without
   // affecting other elements in the location bar.
-  entry_box_ = gtk_hbox_new(FALSE, kInnerPadding);
+  entry_box_ = gtk_hbox_new(FALSE, InnerPadding());
   gtk_widget_show(entry_box_);
   gtk_widget_set_size_request(entry_box_, 0, -1);
   gtk_box_pack_start(GTK_BOX(hbox_.get()), entry_box_, TRUE, TRUE, 0);
 
   // We need to adjust the visibility of the search hint widgets according to
   // the horizontal space in the |entry_box_|.
   g_signal_connect(entry_box_, "size-allocate",
                    G_CALLBACK(&OnEntryBoxSizeAllocateThunk), this);
 
   // Tab to search (the keyword box on the left hand side).
@@ skipping 72 matching lines @@
   if (extensions::switch_utils::IsActionBoxEnabled()) {
     // TODO(mpcomplete): should we hide this if ShouldOnlyShowLocation()==true?
     action_box_button_.reset(new ActionBoxButtonGtk(browser_));
 
     // TODO(mpcomplete): Figure out why CustomDrawButton is offset 3 pixels.
     // This offset corrects the strange offset of CustomDrawButton.
     const int kMagicActionBoxYOffset = 3;
     GtkWidget* alignment = gtk_alignment_new(0, 0, 1, 1);
     gtk_alignment_set_padding(GTK_ALIGNMENT(alignment),
                               0, kMagicActionBoxYOffset,
-                              0, kInnerPadding);
+                              0, InnerPadding());
     gtk_container_add(GTK_CONTAINER(alignment), action_box_button_->widget());
 
     gtk_box_pack_end(GTK_BOX(hbox_.get()), alignment,
                      FALSE, FALSE, 0);
   }
 
   if (browser_defaults::bookmarks_enabled && !ShouldOnlyShowLocation()) {
     // Hide the star icon in popups, app windows, etc.
     CreateStarButton();
     gtk_box_pack_end(GTK_BOX(hbox_.get()), star_.get(), FALSE, FALSE, 0);
   }
 
   CreateZoomButton();
   gtk_box_pack_end(GTK_BOX(hbox_.get()), zoom_.get(), FALSE, FALSE, 0);
 
-  content_setting_hbox_.Own(gtk_hbox_new(FALSE, kInnerPadding + 1));
+  content_setting_hbox_.Own(gtk_hbox_new(FALSE, InnerPadding() + 1));
   gtk_widget_set_name(content_setting_hbox_.get(),
                       "chrome-content-setting-hbox");
   gtk_box_pack_end(GTK_BOX(hbox_.get()), content_setting_hbox_.get(),
                    FALSE, FALSE, 1);
 
   for (int i = 0; i < CONTENT_SETTINGS_NUM_TYPES; ++i) {
     ContentSettingImageViewGtk* content_setting_view =
         new ContentSettingImageViewGtk(
             static_cast<ContentSettingsType>(i), this);
     content_setting_views_.push_back(content_setting_view);
     gtk_box_pack_end(GTK_BOX(content_setting_hbox_.get()),
                      content_setting_view->widget(), FALSE, FALSE, 0);
   }
 
-  page_action_hbox_.Own(gtk_hbox_new(FALSE, kInnerPadding));
+  page_action_hbox_.Own(gtk_hbox_new(FALSE, InnerPadding()));
   gtk_widget_set_name(page_action_hbox_.get(),
                       "chrome-page-action-hbox");
   gtk_box_pack_end(GTK_BOX(hbox_.get()), page_action_hbox_.get(),
                    FALSE, FALSE, 0);
 
-  web_intents_hbox_.Own(gtk_hbox_new(FALSE, kInnerPadding));
+  web_intents_hbox_.Own(gtk_hbox_new(FALSE, InnerPadding()));
   gtk_widget_set_name(web_intents_hbox_.get(),
                       "chrome-web-intents-hbox");
   gtk_box_pack_end(GTK_BOX(hbox_.get()), web_intents_hbox_.get(),
                    FALSE, FALSE, 0);
   gtk_box_pack_end(GTK_BOX(web_intents_hbox_.get()),
                    web_intents_button_view_->widget(), FALSE, FALSE, 0);
 
   // Now that we've created the widget hierarchy, connect to the main |hbox_|'s
   // size-allocate so we can do proper resizing and eliding on
   // |security_info_label_|.
@@ skipping 198 matching lines @@
     ViewID debug_id,
     int tooltip_id,
     gboolean (click_callback)(GtkWidget*, GdkEventButton*, gpointer)) {
   *image = image_id ?
       gtk_image_new_from_pixbuf(
           theme_service_->GetImageNamed(image_id)->ToGdkPixbuf()) :
       gtk_image_new();
 
   GtkWidget* alignment = gtk_alignment_new(0, 0, 1, 1);
   gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 0, 0,
-                            0, kInnerPadding);
+                            0, InnerPadding());
   gtk_container_add(GTK_CONTAINER(alignment), *image);
 
   GtkWidget* result = gtk_event_box_new();
   gtk_event_box_set_visible_window(GTK_EVENT_BOX(result), FALSE);
   gtk_container_add(GTK_CONTAINER(result), alignment);
   gtk_widget_show_all(result);
 
   if (debug_id != VIEW_ID_NONE)
     ViewIDUtil::SetID(result, debug_id);
 
@@ skipping 159 matching lines @@
   }
 
   WebContents* contents = GetWebContents();
   if (!page_action_views_.empty() && contents) {
     GURL url = chrome::GetActiveWebContents(browser())->GetURL();
 
     for (size_t i = 0; i < page_action_views_.size(); i++) {
       page_action_views_[i]->UpdateVisibility(
           toolbar_model_->input_in_progress() ? NULL : contents, url);
     }
+    gtk_widget_queue_draw(hbox_.get());
   }
 
   // If there are no visible page actions, hide the hbox too, so that it does
   // not affect the padding in the location bar.
   gtk_widget_set_visible(page_action_hbox_.get(),
                          PageActionVisibleCount() && !ShouldOnlyShowLocation());
 }
 
 void LocationBarViewGtk::InvalidatePageActions() {
   size_t count_before = page_action_views_.size();
@@ skipping 172 matching lines @@
       left = IDR_LOCATIONBG_L;
       center = IDR_LOCATIONBG_C;
       right = IDR_LOCATIONBG_R;
     }
 
     NineBox background(left, center, right,
                        0, 0, 0, 0, 0, 0);
     background.RenderToWidget(widget);
   }
 
+  // Draw ExtensionAction backgrounds and borders, if necessary.  The borders
+  // appear exactly between the elements, so they can't draw the borders
+  // themselves.
+  gfx::CanvasSkiaPaint canvas(event, /*opaque=*/false);
+  for (ScopedVector<PageActionViewGtk>::const_iterator
+           page_action_view = page_action_views_.begin();
+       page_action_view != page_action_views_.end();
+       ++page_action_view) {
+    if ((*page_action_view)->IsVisible()) {
+      // Figure out where the page action is drawn so we can draw
+      // borders to its left and right.
+      GtkAllocation allocation;
+      gtk_widget_get_allocation((*page_action_view)->widget(), &allocation);
+      ExtensionAction* action = (*page_action_view)->page_action();
+      gfx::Rect bounds(allocation);
+      // Make the bounding rectangle include the whole vertical range of the
+      // location bar, and the mid-point pixels between adjacent page actions.
+      //
+      // For odd InnerPadding()s, "InnerPadding() + 1" includes the mid-point
+      // between two page actions in the bounding rectangle.  For even paddings,
+      // the +1 is dropped, which is right since there is no pixel at the
+      // mid-point.
+      bounds.Inset(-(InnerPadding() + 1) / 2,
+                   theme_service_->UsingNativeTheme() ? -1 : 0);
+      location_bar_util::PaintExtensionActionBackground(
+          *action, SessionID::IdForTab(GetWebContents()),
+          &canvas, bounds,
+          theme_service_->get_location_bar_text_color(),
+          theme_service_->get_location_bar_bg_color());
+    }
+  }
+  // Destroying |canvas| draws the background.
+
   return FALSE;  // Continue propagating the expose.
 }
 
 void LocationBarViewGtk::UpdateSiteTypeArea() {
   // The icon is always visible except when the |tab_to_search_alignment_| is
   // visible.
   if (!location_entry_->model()->keyword().empty() &&
       !location_entry_->model()->is_keyword_hint()) {
     gtk_widget_hide(site_type_area());
     return;
@@ skipping 383 matching lines @@
   command_updater_->UpdateCommandEnabled(IDC_CHROME_TO_MOBILE_PAGE,
       !toolbar_model_->input_in_progress() && service && service->HasMobiles());
 }
 
 bool LocationBarViewGtk::ShouldOnlyShowLocation() {
   return !browser_->is_type_tabbed();
 }
 
 void LocationBarViewGtk::AdjustChildrenVisibility() {
   int text_width = location_entry_->TextWidth();
-  int available_width = entry_box_width_ - text_width - kInnerPadding;
+  int available_width = entry_box_width_ - text_width - InnerPadding();
 
   // Only one of |tab_to_search_alignment_| and |tab_to_search_hint_| can be
   // visible at the same time.
   if (!show_selected_keyword_ &&
       gtk_widget_get_visible(tab_to_search_alignment_)) {
     gtk_widget_hide(tab_to_search_alignment_);
   } else if (!show_keyword_hint_ &&
              gtk_widget_get_visible(tab_to_search_hint_)) {
     gtk_widget_hide(tab_to_search_hint_);
   }
 
   if (show_selected_keyword_) {
     GtkRequisition box, full_label, partial_label;
     gtk_widget_size_request(tab_to_search_box_, &box);
     gtk_widget_size_request(tab_to_search_full_label_, &full_label);
     gtk_widget_size_request(tab_to_search_partial_label_, &partial_label);
     int full_partial_width_diff = full_label.width - partial_label.width;
     int full_box_width;
     int partial_box_width;
     if (gtk_widget_get_visible(tab_to_search_full_label_)) {
       full_box_width = box.width;
       partial_box_width = full_box_width - full_partial_width_diff;
     } else {
       partial_box_width = box.width;
       full_box_width = partial_box_width + full_partial_width_diff;
     }
 
-    if (partial_box_width >= entry_box_width_ - kInnerPadding) {
+    if (partial_box_width >= entry_box_width_ - InnerPadding()) {
       gtk_widget_hide(tab_to_search_alignment_);
     } else if (full_box_width >= available_width) {
       gtk_widget_hide(tab_to_search_full_label_);
       gtk_widget_show(tab_to_search_partial_label_);
       gtk_widget_show(tab_to_search_alignment_);
     } else if (full_box_width < available_width) {
       gtk_widget_hide(tab_to_search_partial_label_);
       gtk_widget_show(tab_to_search_full_label_);
       gtk_widget_show(tab_to_search_alignment_);
     }
   } else if (show_keyword_hint_) {
     GtkRequisition leading, icon, trailing;
     gtk_widget_size_request(tab_to_search_hint_leading_label_, &leading);
     gtk_widget_size_request(tab_to_search_hint_icon_, &icon);
     gtk_widget_size_request(tab_to_search_hint_trailing_label_, &trailing);
     int full_width = leading.width + icon.width + trailing.width;
 
-    if (icon.width >= entry_box_width_ - kInnerPadding) {
+    if (icon.width >= entry_box_width_ - InnerPadding()) {
       gtk_widget_hide(tab_to_search_hint_);
     } else if (full_width >= available_width) {
       gtk_widget_hide(tab_to_search_hint_leading_label_);
       gtk_widget_hide(tab_to_search_hint_trailing_label_);
       gtk_widget_show(tab_to_search_hint_);
     } else if (full_width < available_width) {
       gtk_widget_show(tab_to_search_hint_leading_label_);
       gtk_widget_show(tab_to_search_hint_trailing_label_);
       gtk_widget_show(tab_to_search_hint_);
     }
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // LocationBarViewGtk::PageToolViewGtk
 
 LocationBarViewGtk::PageToolViewGtk::PageToolViewGtk(
     const LocationBarViewGtk* parent)
     : alignment_(gtk_alignment_new(0, 0, 1, 1)),
       event_box_(gtk_event_box_new()),
-      hbox_(gtk_hbox_new(FALSE, kInnerPadding)),
+      hbox_(gtk_hbox_new(FALSE, InnerPadding())),
       image_(gtk_image_new()),
       label_(gtk_label_new(NULL)),
       parent_(parent),
       animation_(this),
       weak_factory_(this) {
   gtk_alignment_set_padding(GTK_ALIGNMENT(alignment_.get()), 1, 1, 0, 0);
   gtk_container_add(GTK_CONTAINER(alignment_.get()), event_box_.get());
 
   // Make the event box not visible so it does not paint a background.
   gtk_event_box_set_visible_window(GTK_EVENT_BOX(event_box_.get()), FALSE);
@@ skipping 449 matching lines @@
 }
 
 void LocationBarViewGtk::PageActionViewGtk::InspectPopup(
     ExtensionAction* action) {
   ExtensionPopupGtk::Show(
       action->GetPopupUrl(current_tab_id_),
       owner_->browser_,
       event_box_.get(),
       ExtensionPopupGtk::SHOW_AND_INSPECT);
 }