[Web Intents] Basic location bar UI for window disposition picker affordance.

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 41 matching lines @@
 #include "chrome/browser/ui/gtk/content_setting_bubble_gtk.h"
 #include "chrome/browser/ui/gtk/extensions/extension_popup_gtk.h"
 #include "chrome/browser/ui/gtk/first_run_bubble.h"
 #include "chrome/browser/ui/gtk/gtk_theme_service.h"
 #include "chrome/browser/ui/gtk/gtk_util.h"
 #include "chrome/browser/ui/gtk/nine_box.h"
 #include "chrome/browser/ui/gtk/omnibox/omnibox_view_gtk.h"
 #include "chrome/browser/ui/gtk/rounded_window.h"
 #include "chrome/browser/ui/gtk/view_id_util.h"
 #include "chrome/browser/ui/gtk/zoom_bubble_gtk.h"
+#include "chrome/browser/ui/intents/web_intent_picker_controller.h"
 #include "chrome/browser/ui/omnibox/location_bar_util.h"
 #include "chrome/browser/ui/omnibox/omnibox_edit_model.h"
 #include "chrome/browser/ui/omnibox/omnibox_popup_model.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/webui/extensions/extension_info_ui.h"
 #include "chrome/browser/ui/zoom/zoom_controller.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_action.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
@@ skipping 61 matching lines @@
 const GdkColor kHintTextColor = GDK_COLOR_RGB(0x75, 0x75, 0x75);
 
 // Size of the rounding of the "Search site for:" box.
 const int kCornerSize = 3;
 
 // The time, in ms, that the content setting label is fully displayed, for the
 // cases where we animate it into and out of view.
 const int kContentSettingImageDisplayTime = 3200;
 // The time, in ms, of the animation (open and close).
 const int kContentSettingImageAnimationTime = 150;
+const int kPageToolAnimationTime = 1000;
 
 // Color of border of content setting area (icon/label).
 const GdkColor kContentSettingBorderColor = GDK_COLOR_RGB(0xe9, 0xb9, 0x66);
 // Colors for the background gradient.
-const double kContentSettingTopColor[] = { 0xff / 255.0,
-                                           0xf8 / 255.0,
-                                           0xd4 / 255.0 };
-const double kContentSettingBottomColor[] = { 0xff / 255.0,
-                                              0xe6 / 255.0,
-                                              0xaf / 255.0 };
+const GdkColor kContentSettingTopColor = GDK_COLOR_RGB(0xff, 0xf8, 0xd4);
+const GdkColor kContentSettingBottomColor = GDK_COLOR_RGB(0xff, 0xe6, 0xaf);
+
+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);
 
 // 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;
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // LocationBarViewGtk
 
 // static
 const GdkColor LocationBarViewGtk::kBackgroundColor =
     GDK_COLOR_RGB(255, 255, 255);
 
 LocationBarViewGtk::LocationBarViewGtk(Browser* browser)
     : zoom_image_(NULL),
       star_image_(NULL),
       starred_(false),
       chrome_to_mobile_image_(NULL),
       site_type_alignment_(NULL),
       site_type_event_box_(NULL),
       location_icon_image_(NULL),
       drag_icon_(NULL),
       enable_location_drag_(false),
       security_info_label_(NULL),
+      web_intents_tool_view_(this),
       tab_to_search_alignment_(NULL),
       tab_to_search_box_(NULL),
       tab_to_search_full_label_(NULL),
       tab_to_search_partial_label_(NULL),
       tab_to_search_hint_(NULL),
       tab_to_search_hint_leading_label_(NULL),
       tab_to_search_hint_icon_(NULL),
       tab_to_search_hint_trailing_label_(NULL),
       command_updater_(browser->command_controller()->command_updater()),
       toolbar_model_(browser->toolbar_model()),
@@ skipping 12 matching lines @@
 }
 
 LocationBarViewGtk::~LocationBarViewGtk() {
   // All of our widgets should be children of / owned by the alignment.
   zoom_.Destroy();
   star_.Destroy();
   chrome_to_mobile_view_.Destroy();
   hbox_.Destroy();
   content_setting_hbox_.Destroy();
   page_action_hbox_.Destroy();
+  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));
@@ skipping 135 matching lines @@
     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));
   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));
+  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_tool_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_|.
   g_signal_connect(hbox_.get(), "size-allocate",
                    G_CALLBACK(&OnHboxSizeAllocateThunk), this);
 
   registrar_.Add(this,
                  chrome::NOTIFICATION_BROWSER_THEME_CHANGED,
                  content::Source<ThemeService>(theme_service_));
   registrar_.Add(this,
@@ skipping 111 matching lines @@
   return NULL;
 }
 
 void LocationBarViewGtk::Update(const WebContents* contents) {
   UpdateZoomIcon();
   UpdateStarIcon();
   UpdateChromeToMobileIcon();
   UpdateSiteTypeArea();
   UpdateContentSettingsIcons();
   UpdatePageActions();
+  UpdateWebIntentsTool();
   location_entry_->Update(contents);
   // The security level (background color) could have changed, etc.
   if (theme_service_->UsingNativeTheme()) {
     // In GTK mode, we need our parent to redraw, as it draws the text entry
     // border.
     gtk_widget_queue_draw(gtk_widget_get_parent(widget()));
   } else {
     gtk_widget_queue_draw(widget());
   }
 }
@@ skipping 193 matching lines @@
   if (select_all)
     location_entry_->SelectAll(true);
 }
 
 void LocationBarViewGtk::FocusSearch() {
   location_entry_->SetFocus();
   location_entry_->SetForcedQuery();
 }
 
 void LocationBarViewGtk::UpdateContentSettingsIcons() {
-  WebContents* web_contents = GetWebContents();
   bool any_visible = false;
   for (ScopedVector<ContentSettingImageViewGtk>::iterator i(
            content_setting_views_.begin());
        i != content_setting_views_.end(); ++i) {
-    (*i)->UpdateFromWebContents(
-        toolbar_model_->input_in_progress() ? NULL : web_contents);
+    (*i)->Update(
+        toolbar_model_->input_in_progress() ? NULL : GetTabContents());
     any_visible = (*i)->IsVisible() || any_visible;
   }
 
   // If there are no visible content things, hide the top level box so it
   // doesn't mess with padding.
   gtk_widget_set_visible(content_setting_hbox_.get(), any_visible);
 }
 
 void LocationBarViewGtk::UpdatePageActions() {
   std::vector<ExtensionAction*> new_page_actions;
@@ skipping 43 matching lines @@
   size_t count_before = page_action_views_.size();
   page_action_views_.clear();
   if (page_action_views_.size() != count_before) {
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_EXTENSION_PAGE_ACTION_COUNT_CHANGED,
         content::Source<LocationBar>(this),
         content::NotificationService::NoDetails());
   }
 }
 
+void LocationBarViewGtk::UpdateWebIntentsTool() {
+  web_intents_tool_view_.Update(GetTabContents());
+  gtk_widget_set_visible(web_intents_hbox_.get(),
+                         web_intents_tool_view_.IsVisible());
+}
+
 void LocationBarViewGtk::SaveStateToContents(WebContents* contents) {
   location_entry_->SaveStateToTab(contents);
 }
 
 void LocationBarViewGtk::Revert() {
   location_entry_->RevertAll();
 }
 
 const OmniboxView* LocationBarViewGtk::GetLocationEntry() const {
   return location_entry_.get();
@@ skipping 122 matching lines @@
                                   1, 1, 0, 0);
         gtk_alignment_set_padding(GTK_ALIGNMENT(site_type_alignment_),
                                   1, 1, 0, 0);
       }
 
       UpdateZoomIcon();
       UpdateStarIcon();
       UpdateChromeToMobileIcon();
       UpdateSiteTypeArea();
       UpdateContentSettingsIcons();
+      UpdateWebIntentsTool();
       break;
     }
 
     default:
       NOTREACHED();
   }
 }
 
 gboolean LocationBarViewGtk::HandleExpose(GtkWidget* widget,
                                           GdkEventExpose* event) {
@@ skipping 472 matching lines @@
       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::ContentSettingImageViewGtk
-LocationBarViewGtk::ContentSettingImageViewGtk::ContentSettingImageViewGtk(
-    ContentSettingsType content_type,
+// LocationBarViewGtk::PageToolViewGtk
+
+LocationBarViewGtk::PageToolViewGtk::PageToolViewGtk(
     const LocationBarViewGtk* parent)
-    : content_setting_image_model_(
-          ContentSettingImageModel::CreateContentSettingImageModel(
-              content_type)),
-      alignment_(gtk_alignment_new(0, 0, 1, 1)),
+    : alignment_(gtk_alignment_new(0, 0, 1, 1)),
       event_box_(gtk_event_box_new()),
       hbox_(gtk_hbox_new(FALSE, kInnerPadding)),
       image_(gtk_image_new()),
       label_(gtk_label_new(NULL)),
       parent_(parent),
-      content_setting_bubble_(NULL),
       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);
   g_signal_connect(event_box_.get(), "button-press-event",
                    G_CALLBACK(&OnButtonPressedThunk), this);
   g_signal_connect(event_box_.get(), "expose-event",
                    G_CALLBACK(&OnExposeThunk), this);
 
   gtk_widget_set_no_show_all(label_.get(), TRUE);
   gtk_label_set_line_wrap(GTK_LABEL(label_.get()), FALSE);
 
   gtk_box_pack_start(GTK_BOX(hbox_), image_.get(), FALSE, FALSE, 0);
   gtk_box_pack_start(GTK_BOX(hbox_), label_.get(), FALSE, FALSE, 0);
 
   gtk_container_set_border_width(GTK_CONTAINER(hbox_), kHboxBorder);
 
   gtk_container_add(GTK_CONTAINER(event_box_.get()), hbox_);
   gtk_widget_hide(widget());
 
-  animation_.SetSlideDuration(kContentSettingImageAnimationTime);
+  animation_.SetSlideDuration(kPageToolAnimationTime);
 }
 
-LocationBarViewGtk::ContentSettingImageViewGtk::~ContentSettingImageViewGtk() {
+LocationBarViewGtk::PageToolViewGtk::~PageToolViewGtk() {
   image_.Destroy();
   label_.Destroy();
   event_box_.Destroy();
   alignment_.Destroy();
-
-  if (content_setting_bubble_)
-    content_setting_bubble_->Close();
 }
 
-bool LocationBarViewGtk::ContentSettingImageViewGtk::IsVisible() {
+GtkWidget* LocationBarViewGtk::PageToolViewGtk::widget() {
+  return alignment_.get();
+}
+
+bool LocationBarViewGtk::PageToolViewGtk::IsVisible() {
   return gtk_widget_get_visible(widget());
 }
 
-void LocationBarViewGtk::ContentSettingImageViewGtk::UpdateFromWebContents(
-    WebContents* web_contents) {
-  content_setting_image_model_->UpdateFromWebContents(web_contents);
-  if (!content_setting_image_model_->is_visible()) {
+void LocationBarViewGtk::PageToolViewGtk::Update(

[Bernhard Bauer, 2012/07/27 00:35:38]

Where is this method called?

+    TabContents* tab_contents) {
+  if (!tab_contents ||
+      !tab_contents->web_intent_picker_controller() ||

[Bernhard Bauer, 2012/07/27 00:35:38]

This still seems to be Web Intents specific?

+      !tab_contents->web_intent_picker_controller()->
+           ShowLocationBarPickerTool()) {
     gtk_widget_hide(widget());
     return;
   }
 
-  gtk_image_set_from_pixbuf(GTK_IMAGE(image_.get()),
-      GtkThemeService::GetFrom(parent_->browser()->profile())->GetImageNamed(
-          content_setting_image_model_->get_icon())->ToGdkPixbuf());
-
   gtk_widget_set_tooltip_text(widget(),
-      content_setting_image_model_->get_tooltip().c_str());
+      l10n_util::GetStringUTF8(IDS_INTENT_PICKER_USE_ANOTHER_SERVICE).c_str());
   gtk_widget_show_all(widget());
 
-  TabSpecificContentSettings* content_settings = NULL;
-  if (web_contents) {
-    content_settings =
-        TabContents::FromWebContents(web_contents)->content_settings();
-  }
-  if (!content_settings || content_settings->IsBlockageIndicated(
-      content_setting_image_model_->get_content_settings_type()))
-    return;
+  gtk_label_set_text(GTK_LABEL(label_.get()),
+      l10n_util::GetStringUTF8(IDS_INTENT_PICKER_USE_ANOTHER_SERVICE).c_str());
 
-  // The content blockage was not yet indicated to the user. Start indication
-  // animation and clear "not yet shown" flag.
-  content_settings->SetBlockageHasBeenIndicated(
-      content_setting_image_model_->get_content_settings_type());
-
-  int label_string_id =
-      content_setting_image_model_->explanatory_string_id();
-  // If there's no string for the content type, we don't animate.
-  if (!label_string_id)
-    return;
-
-  gtk_label_set_text(GTK_LABEL(label_.get()),
-      l10n_util::GetStringUTF8(label_string_id).c_str());
   StartAnimating();
 }
 
-void LocationBarViewGtk::ContentSettingImageViewGtk::StartAnimating() {
+GdkColor LocationBarViewGtk::PageToolViewGtk::button_border_color() const {
+  return kGrayBorderColor;
+}
+
+void LocationBarViewGtk::PageToolViewGtk::StartAnimating() {
   if (animation_.IsShowing() || animation_.IsClosing())
     return;
 
   gtk_event_box_set_visible_window(GTK_EVENT_BOX(event_box_.get()), TRUE);
-  gtk_util::ActAsRoundedWindow(event_box_.get(), kContentSettingBorderColor,
+  GdkColor border_color = button_border_color();
+  gtk_util::ActAsRoundedWindow(event_box_.get(), border_color,
                                kCornerSize,
                                gtk_util::ROUNDED_ALL, gtk_util::BORDER_ALL);
 
   gtk_widget_set_size_request(label_.get(), -1, -1);
   gtk_widget_size_request(label_.get(), &label_req_);
   gtk_widget_set_size_request(label_.get(), 0, -1);
   gtk_widget_show(label_.get());
 
   animation_.Show();
 }
 
-void LocationBarViewGtk::ContentSettingImageViewGtk::CloseAnimation() {
+void LocationBarViewGtk::PageToolViewGtk::CloseAnimation() {
   animation_.Hide();
 }
 
-void LocationBarViewGtk::ContentSettingImageViewGtk::AnimationProgressed(
+void LocationBarViewGtk::PageToolViewGtk::AnimationProgressed(
     const ui::Animation* animation) {
   gtk_widget_set_size_request(
       label_.get(),
       animation->GetCurrentValue() * label_req_.width,
       -1);
 }
 
-void LocationBarViewGtk::ContentSettingImageViewGtk::AnimationEnded(
+void LocationBarViewGtk::PageToolViewGtk::AnimationCanceled(
     const ui::Animation* animation) {
-  if (animation_.IsShowing()) {
-    MessageLoop::current()->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&ContentSettingImageViewGtk::CloseAnimation,
-                   weak_factory_.GetWeakPtr()),
-        base::TimeDelta::FromMilliseconds(kContentSettingImageDisplayTime));
-  } else {
+}
+
+void LocationBarViewGtk::PageToolViewGtk::AnimationEnded(
+    const ui::Animation* animation) {
+  if (!animation_.IsShowing()) {
     gtk_widget_hide(label_.get());
     gtk_util::StopActingAsRoundedWindow(event_box_.get());
     gtk_event_box_set_visible_window(GTK_EVENT_BOX(event_box_.get()), FALSE);
   }
 }
 
-void LocationBarViewGtk::ContentSettingImageViewGtk::AnimationCanceled(
-    const ui::Animation* animation) {
-}
-
-gboolean LocationBarViewGtk::ContentSettingImageViewGtk::OnButtonPressed(
+gboolean LocationBarViewGtk::PageToolViewGtk::OnButtonPressed(
     GtkWidget* sender, GdkEvent* event) {
-  TabContents* tab_contents = parent_->GetTabContents();
-  if (!tab_contents)
-    return TRUE;
-  Profile* profile = parent_->browser()->profile();
-  content_setting_bubble_ = new ContentSettingBubbleGtk(
-      sender, this,
-      ContentSettingBubbleModel::CreateContentSettingBubbleModel(
-          parent_->browser()->content_setting_bubble_model_delegate(),
-          tab_contents,
-          profile,
-          content_setting_image_model_->get_content_settings_type()),
-      profile, tab_contents->web_contents());
+  OnClick(sender);
   return TRUE;
 }
 
-gboolean LocationBarViewGtk::ContentSettingImageViewGtk::OnExpose(
+void LocationBarViewGtk::PageToolViewGtk::OnClick(GtkWidget* sender) {
+  LOG(INFO) << "CLICK!!!";
+}
+
+GdkColor LocationBarViewGtk::PageToolViewGtk::gradient_top_color() const {
+  return kTopColorGray;
+}
+
+GdkColor LocationBarViewGtk::PageToolViewGtk::gradient_bottom_color() const {
+  return kBottomColorGray;
+}
+
+gboolean LocationBarViewGtk::PageToolViewGtk::OnExpose(
     GtkWidget* sender, GdkEventExpose* event) {
-  TRACE_EVENT0("ui::gtk",
-               "LocationBarViewGtk::ContentSettingImageViewGtk::OnExpose");
+  TRACE_EVENT0("ui::gtk", "LocationBarViewGtk::PageToolViewGtk::OnExpose");
 
   if (!(animation_.IsShowing() || animation_.IsClosing()))
     return FALSE;
 
   GtkAllocation allocation;
   gtk_widget_get_allocation(sender, &allocation);
   const int height = allocation.height;
 
   cairo_t* cr = gdk_cairo_create(gtk_widget_get_window(sender));
   gdk_cairo_rectangle(cr, &event->area);
   cairo_clip(cr);
 
   cairo_pattern_t* pattern = cairo_pattern_create_linear(0, 0, 0, height);
 
-  cairo_pattern_add_color_stop_rgb(pattern, 0.0,
-                                   kContentSettingTopColor[0],
-                                   kContentSettingTopColor[1],
-                                   kContentSettingTopColor[2]);
-  cairo_pattern_add_color_stop_rgb(pattern, 1.0,
-                                   kContentSettingBottomColor[0],
-                                   kContentSettingBottomColor[1],
-                                   kContentSettingBottomColor[2]);
+  const GdkColor top_color = gradient_top_color();
+  const GdkColor bottom_color = gradient_bottom_color();
+  cairo_pattern_add_color_stop_rgb(
+      pattern, 0.0,
+      top_color.red/255.0,
+      top_color.blue/255.0,
+      top_color.green/255.0);
+  cairo_pattern_add_color_stop_rgb(
+      pattern, 1.0,
+      bottom_color.red/255.0,
+      bottom_color.blue/255.0,
+      bottom_color.green/255.0);
+
   cairo_set_source(cr, pattern);
   cairo_paint(cr);
   cairo_pattern_destroy(pattern);
   cairo_destroy(cr);
 
   return FALSE;
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// LocationBarViewGtk::ContentSettingImageViewGtk
+LocationBarViewGtk::ContentSettingImageViewGtk::ContentSettingImageViewGtk(
+    ContentSettingsType content_type,
+    const LocationBarViewGtk* parent)
+    : PageToolViewGtk(parent),
+      content_setting_image_model_(
+          ContentSettingImageModel::CreateContentSettingImageModel(
+              content_type)),
+      content_setting_bubble_(NULL) {
+  animation_.SetSlideDuration(kContentSettingImageAnimationTime);
+}
+
+LocationBarViewGtk::ContentSettingImageViewGtk::~ContentSettingImageViewGtk() {
+  if (content_setting_bubble_)
+    content_setting_bubble_->Close();
+}
+
+void LocationBarViewGtk::ContentSettingImageViewGtk::Update(
+    TabContents* tab_contents) {
+  if (tab_contents) {
+    content_setting_image_model_->UpdateFromWebContents(
+        tab_contents->web_contents());
+  }
+  if (!content_setting_image_model_->is_visible()) {
+    gtk_widget_hide(widget());
+    return;
+  }
+
+  gtk_image_set_from_pixbuf(GTK_IMAGE(image_.get()),
+      GtkThemeService::GetFrom(parent_->browser()->profile())->GetImageNamed(
+          content_setting_image_model_->get_icon())->ToGdkPixbuf());
+
+  gtk_widget_set_tooltip_text(widget(),
+      content_setting_image_model_->get_tooltip().c_str());
+  gtk_widget_show_all(widget());
+
+  if (!tab_contents)
+    return;
+
+  TabSpecificContentSettings* content_settings =
+      tab_contents->content_settings();
+  if (!content_settings || content_settings->IsBlockageIndicated(
+      content_setting_image_model_->get_content_settings_type()))
+    return;
+
+  // The content blockage was not yet indicated to the user. Start indication
+  // animation and clear "not yet shown" flag.
+  content_settings->SetBlockageHasBeenIndicated(
+      content_setting_image_model_->get_content_settings_type());
+
+  int label_string_id =
+      content_setting_image_model_->explanatory_string_id();
+  // If there's no string for the content type, we don't animate.
+  if (!label_string_id)
+    return;
+
+  gtk_label_set_text(GTK_LABEL(label_.get()),
+      l10n_util::GetStringUTF8(label_string_id).c_str());
+  StartAnimating();
+}
+
+void LocationBarViewGtk::ContentSettingImageViewGtk::AnimationEnded(
+    const ui::Animation* animation) {
+  if (animation_.IsShowing()) {
+    MessageLoop::current()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&ContentSettingImageViewGtk::CloseAnimation,
+                   weak_factory_.GetWeakPtr()),
+        base::TimeDelta::FromMilliseconds(kContentSettingImageDisplayTime));
+  } else {
+    gtk_widget_hide(label_.get());
+    gtk_util::StopActingAsRoundedWindow(event_box_.get());
+    gtk_event_box_set_visible_window(GTK_EVENT_BOX(event_box_.get()), FALSE);
+  }
+}
+
+GdkColor LocationBarViewGtk::ContentSettingImageViewGtk::
+    button_border_color() const {
+  return kContentSettingBorderColor;
+}
+
+GdkColor LocationBarViewGtk::ContentSettingImageViewGtk::
+    gradient_top_color() const {
+  return kContentSettingTopColor;
+}
+
+GdkColor LocationBarViewGtk::ContentSettingImageViewGtk::
+    gradient_bottom_color() const {
+  return kContentSettingBottomColor;
+}
+
+void LocationBarViewGtk::ContentSettingImageViewGtk::OnClick(
+    GtkWidget* sender) {
+  TabContents* tab_contents = parent_->GetTabContents();
+  if (!tab_contents)
+    return;
+  Profile* profile = parent_->browser()->profile();
+  content_setting_bubble_ = new ContentSettingBubbleGtk(
+      sender, this,
+      ContentSettingBubbleModel::CreateContentSettingBubbleModel(
+          parent_->browser()->content_setting_bubble_model_delegate(),
+          tab_contents,
+          profile,
+          content_setting_image_model_->get_content_settings_type()),
+      profile, tab_contents->web_contents());
+  return;
+}
+
 void LocationBarViewGtk::ContentSettingImageViewGtk::BubbleClosing(
     BubbleGtk* bubble,
     bool closed_by_escape) {
   content_setting_bubble_ = NULL;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // LocationBarViewGtk::PageActionViewGtk
 
 LocationBarViewGtk::PageActionViewGtk::PageActionViewGtk(
@@ skipping 352 matching lines @@
 }
 
 void LocationBarViewGtk::PageActionViewGtk::InspectPopup(
     ExtensionAction* action) {
   ExtensionPopupGtk::Show(
       action->GetPopupUrl(current_tab_id_),
       owner_->browser_,
       event_box_.get(),
       ExtensionPopupGtk::SHOW_AND_INSPECT);
 }