Move download shelf from per-tab to per-window

chrome/browser/gtk/download_item_gtk.cc

 // Copyright (c) 2009 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/gtk/download_item_gtk.h"
 
 #include "app/l10n_util.h"
 #include "app/gfx/canvas.h"
 #include "app/gfx/font.h"
 #include "app/gfx/text_elider.h"
@@ skipping 159 matching lines @@
     : parent_shelf_(parent_shelf),
       menu_showing_(false),
       progress_angle_(download_util::kStartAngleDegrees),
       download_model_(download_model),
       bounding_widget_(parent_shelf->GetRightBoundingWidget()),
       dangerous_prompt_(NULL),
       icon_(NULL) {
   InitNineBoxes();
   LoadIcon();
 
-  body_ = gtk_button_new();
-  gtk_widget_set_app_paintable(body_, TRUE);
-  g_signal_connect(body_, "expose-event",
+  body_.Own(gtk_button_new());
+  gtk_widget_set_app_paintable(body_.get(), TRUE);
+  g_signal_connect(body_.get(), "expose-event",
                    G_CALLBACK(OnExpose), this);
-  g_signal_connect(body_, "clicked",
+  g_signal_connect(body_.get(), "clicked",
                    G_CALLBACK(OnClick), this);
-  GTK_WIDGET_UNSET_FLAGS(body_, GTK_CAN_FOCUS);
+  GTK_WIDGET_UNSET_FLAGS(body_.get(), GTK_CAN_FOCUS);
   // Remove internal padding on the button.
   GtkRcStyle* no_padding_style = gtk_rc_style_new();
   no_padding_style->xthickness = 0;
   no_padding_style->ythickness = 0;
-  gtk_widget_modify_style(body_, no_padding_style);
+  gtk_widget_modify_style(body_.get(), no_padding_style);
   g_object_unref(no_padding_style);
 
   name_label_ = gtk_label_new(NULL);
 
   // TODO(estade): This is at best an educated guess, since we don't actually
   // use gfx::Font() to draw the text. This is why we need to add so
   // much padding when we set the size request. We need to either use gfx::Font
   // or somehow extend TextElider.
   std::wstring elided_filename = gfx::ElideFilename(
       get_download()->GetFileName(),
@@ skipping 12 matching lines @@
   gtk_util::ForceFontSizePixels(name_label_, 13.4);  // 13.4px == 10pt @ 96dpi
   gtk_util::ForceFontSizePixels(status_label_, 13.4);  // 13.4px == 10pt @ 96dpi
 
   // Stack the labels on top of one another.
   GtkWidget* text_stack = gtk_vbox_new(FALSE, 0);
   gtk_box_pack_start(GTK_BOX(text_stack), name_label_, TRUE, TRUE, 0);
   gtk_box_pack_start(GTK_BOX(text_stack), status_label_, FALSE, FALSE, 0);
 
   // We use a GtkFixed because we don't want it to have its own window.
   // This choice of widget is not critically important though.
-  progress_area_ = gtk_fixed_new();
-  gtk_widget_set_size_request(progress_area_,
+  progress_area_.Own(gtk_fixed_new());
+  gtk_widget_set_size_request(progress_area_.get(),
       download_util::kSmallProgressIconSize,
       download_util::kSmallProgressIconSize);
-  gtk_widget_set_app_paintable(progress_area_, TRUE);
-  g_signal_connect(progress_area_, "expose-event",
+  gtk_widget_set_app_paintable(progress_area_.get(), TRUE);
+  g_signal_connect(progress_area_.get(), "expose-event",
                    G_CALLBACK(OnProgressAreaExpose), this);
 
   // Put the download progress icon on the left of the labels.
   GtkWidget* body_hbox = gtk_hbox_new(FALSE, 0);
-  gtk_container_add(GTK_CONTAINER(body_), body_hbox);
-  gtk_box_pack_start(GTK_BOX(body_hbox), progress_area_, FALSE, FALSE, 0);
+  gtk_container_add(GTK_CONTAINER(body_.get()), body_hbox);
+  gtk_box_pack_start(GTK_BOX(body_hbox), progress_area_.get(), FALSE, FALSE, 0);
   gtk_box_pack_start(GTK_BOX(body_hbox), text_stack, TRUE, TRUE, 0);
 
   menu_button_ = gtk_button_new();
   gtk_widget_set_app_paintable(menu_button_, TRUE);
   GTK_WIDGET_UNSET_FLAGS(menu_button_, GTK_CAN_FOCUS);
   g_signal_connect(menu_button_, "expose-event",
                    G_CALLBACK(OnExpose), this);
   g_signal_connect(menu_button_, "button-press-event",
                    G_CALLBACK(OnMenuButtonPressEvent), this);
   g_object_set_data(G_OBJECT(menu_button_), "left-align-popup",
                     reinterpret_cast<void*>(true));
   gtk_widget_set_size_request(menu_button_, kMenuButtonWidth, 0);
 
   GtkWidget* shelf_hbox = parent_shelf->GetHBox();
-  hbox_ = gtk_hbox_new(FALSE, 0);
-  gtk_box_pack_start(GTK_BOX(hbox_), body_, FALSE, FALSE, 0);
-  gtk_box_pack_start(GTK_BOX(hbox_), menu_button_, FALSE, FALSE, 0);
-  gtk_box_pack_start(GTK_BOX(shelf_hbox), hbox_, FALSE, FALSE, 0);
+  hbox_.Own(gtk_hbox_new(FALSE, 0));
+  gtk_box_pack_start(GTK_BOX(hbox_.get()), body_.get(), FALSE, FALSE, 0);
+  gtk_box_pack_start(GTK_BOX(hbox_.get()), menu_button_, FALSE, FALSE, 0);
+  gtk_box_pack_start(GTK_BOX(shelf_hbox), hbox_.get(), FALSE, FALSE, 0);
   // Insert as the leftmost item.
-  gtk_box_reorder_child(GTK_BOX(shelf_hbox), hbox_, 1);
+  gtk_box_reorder_child(GTK_BOX(shelf_hbox), hbox_.get(), 1);
 
   resize_handler_id_ = g_signal_connect(G_OBJECT(shelf_hbox), "size-allocate",
                                         G_CALLBACK(OnShelfResized), this);
 
   get_download()->AddObserver(this);
 
   new_item_animation_.reset(new SlideAnimation(this));
   new_item_animation_->SetSlideDuration(kNewItemAnimationDurationMs);
-  gtk_widget_show_all(hbox_);
+  gtk_widget_show_all(hbox_.get());
 
   if (IsDangerous()) {
     // Hide the download item components for now.
-    gtk_widget_hide(body_);
+    gtk_widget_hide(body_.get());
     gtk_widget_hide(menu_button_);
 
     // Create an hbox to hold it all.
     dangerous_hbox_ = gtk_hbox_new(FALSE, kDangerousElementPadding);
 
     // Add padding at the beginning and end. The hbox will add padding between
     // the empty labels and the other elements.
     GtkWidget* empty_label_a = gtk_label_new(NULL);
     GtkWidget* empty_label_b = gtk_label_new(NULL);
     gtk_box_pack_start(GTK_BOX(dangerous_hbox_), empty_label_a,
@@ skipping 41 matching lines @@
     g_signal_connect(dangerous_decline, "clicked",
                      G_CALLBACK(OnDangerousDecline), this);
     gtk_util::CenterWidgetInHBox(dangerous_hbox_, dangerous_decline, false, 0);
 
     // Put it in an alignment so that padding will be added on the left and
     // right.
     dangerous_prompt_ = gtk_alignment_new(0.0, 0.0, 1.0, 1.0);
     gtk_alignment_set_padding(GTK_ALIGNMENT(dangerous_prompt_),
         0, 0, kDangerousElementPadding, kDangerousElementPadding);
     gtk_container_add(GTK_CONTAINER(dangerous_prompt_), dangerous_hbox_);
-    gtk_box_pack_start(GTK_BOX(hbox_), dangerous_prompt_, FALSE, FALSE, 0);
+    gtk_box_pack_start(GTK_BOX(hbox_.get()), dangerous_prompt_, FALSE, FALSE, 0);
     gtk_widget_set_app_paintable(dangerous_prompt_, TRUE);
     g_signal_connect(dangerous_prompt_, "expose-event",
                      G_CALLBACK(OnDangerousPromptExpose), this);
     gtk_widget_show_all(dangerous_prompt_);
 
     // The width will depend on the text.
     GtkRequisition req;
     gtk_widget_size_request(dangerous_hbox_, &req);
     dangerous_hbox_full_width_ = req.width;
     gtk_widget_size_request(dangerous_label, &req);
     dangerous_hbox_start_width_ = dangerous_hbox_full_width_ - req.width;
   }
 
   new_item_animation_->Show();
 }
 
 DownloadItemGtk::~DownloadItemGtk() {
   StopDownloadProgress();
-  g_signal_handler_disconnect(parent_shelf_->GetHBox(), resize_handler_id_);
-  gtk_widget_destroy(hbox_);
+
+  // If the top-level window was already destroyed, the signal handler was
+  // already disconnected. Disconnect if that's not the case.
+  if (g_signal_handler_find(parent_shelf_->GetHBox(),
+                            G_SIGNAL_MATCH_ID,
+                            resize_handler_id_,
+                            0,
+                            NULL,
+                            NULL,
+                            NULL) != 0) {
+    g_signal_handler_disconnect(parent_shelf_->GetHBox(), resize_handler_id_);
+  }
   get_download()->RemoveObserver(this);
+
+  hbox_.Destroy();
+  progress_area_.Destroy();
+  body_.Destroy();
 }
 
 void DownloadItemGtk::OnDownloadUpdated(DownloadItem* download) {
   DCHECK_EQ(download, get_download());
 
   if (dangerous_prompt_ != NULL &&
       download->safety_state() == DownloadItem::DANGEROUS_BUT_VALIDATED) {
     // We have been approved.
-    gtk_widget_show_all(hbox_);
+    gtk_widget_show_all(hbox_.get());
     gtk_widget_destroy(dangerous_prompt_);
     dangerous_prompt_ = NULL;
   }
 
   switch (download->state()) {
     case DownloadItem::REMOVING:
       parent_shelf_->RemoveDownloadItem(this);  // This will delete us!
       return;
     case DownloadItem::CANCELLED:
       StopDownloadProgress();
@@ skipping 29 matching lines @@
 
   gchar* label_markup =
       g_markup_printf_escaped(kLabelColorMarkup, kStatusColor,
                               WideToUTF8(status_text).c_str());
   gtk_label_set_markup(GTK_LABEL(status_label_), label_markup);
   g_free(label_markup);
 }
 
 void DownloadItemGtk::AnimationProgressed(const Animation* animation) {
   if (animation == complete_animation_.get()) {
-    gtk_widget_queue_draw(progress_area_);
+    gtk_widget_queue_draw(progress_area_.get());
   } else {
     if (IsDangerous()) {
       int progress = (dangerous_hbox_full_width_ -
                      dangerous_hbox_start_width_) *
                      new_item_animation_->GetCurrentValue();
       int showing_width = dangerous_hbox_start_width_ + progress;
       showing_width = std::max(kMinDangerousDownloadWidth, showing_width);
       gtk_widget_set_size_request(dangerous_hbox_, showing_width, -1);
     } else {
       DCHECK(animation == new_item_animation_.get());
       // See above TODO for explanation of the extra 50.
       int showing_width = std::max(kMinDownloadItemWidth,
           static_cast<int>((kTextWidth + 50 +
                            download_util::kSmallProgressIconSize) *
                            new_item_animation_->GetCurrentValue()));
       showing_width = std::max(showing_width, kMinDownloadItemWidth);
-      gtk_widget_set_size_request(body_, showing_width, -1);
+      gtk_widget_set_size_request(body_.get(), showing_width, -1);
     }
   }
 }
 
 DownloadItem* DownloadItemGtk::get_download() {
   return download_model_->download();
 }
 
 bool DownloadItemGtk::IsDangerous() {
   return get_download()->safety_state() == DownloadItem::DANGEROUS;
 }
 
 // Download progress animation functions.
 
 void DownloadItemGtk::UpdateDownloadProgress() {
   progress_angle_ = (progress_angle_ +
                      download_util::kUnknownIncrementDegrees) %
                     download_util::kMaxDegrees;
-  gtk_widget_queue_draw(progress_area_);
+  gtk_widget_queue_draw(progress_area_.get());
 }
 
 void DownloadItemGtk::StartDownloadProgress() {
   if (progress_timer_.IsRunning())
     return;
   progress_timer_.Start(
       base::TimeDelta::FromMilliseconds(download_util::kProgressRateMs), this,
       &DownloadItemGtk::UpdateDownloadProgress);
 }
 
 void DownloadItemGtk::StopDownloadProgress() {
   progress_timer_.Stop();
 }
 
 // Icon loading functions.
 
 void DownloadItemGtk::OnLoadIconComplete(IconManager::Handle handle,
                                          SkBitmap* icon_bitmap) {
   icon_ = icon_bitmap;
-  gtk_widget_queue_draw(progress_area_);
+  gtk_widget_queue_draw(progress_area_.get());
 }
 
 void DownloadItemGtk::LoadIcon() {
   IconManager* im = g_browser_process->icon_manager();
   im->LoadIcon(get_download()->full_path(),
                IconLoader::SMALL, &icon_consumer_,
                NewCallback(this, &DownloadItemGtk::OnLoadIconComplete));
 }
 
 // static
@@ skipping 59 matching lines @@
       IDR_DOWNLOAD_BUTTON_LEFT_BOTTOM,
       IDR_DOWNLOAD_BUTTON_CENTER_BOTTOM,
       IDR_DOWNLOAD_BUTTON_RIGHT_BOTTOM_NO_DD);
 }
 
 // static
 gboolean DownloadItemGtk::OnExpose(GtkWidget* widget, GdkEventExpose* e,
                                    DownloadItemGtk* download_item) {
   NineBox* nine_box = NULL;
   // If true, this widget is |body_|, otherwise it is |menu_button_|.
-  bool is_body = widget == download_item->body_;
+  bool is_body = widget == download_item->body_.get();
   if (GTK_WIDGET_STATE(widget) == GTK_STATE_PRELIGHT)
     nine_box = is_body ? body_nine_box_prelight_ : menu_nine_box_prelight_;
   else if (GTK_WIDGET_STATE(widget) == GTK_STATE_ACTIVE)
     nine_box = is_body ? body_nine_box_active_ : menu_nine_box_active_;
   else
     nine_box = is_body ? body_nine_box_normal_ : menu_nine_box_normal_;
 
   // When the button is showing, we want to draw it as active. We have to do
   // this explicitly because the button's state will be NORMAL while the menu
   // has focus.
@@ skipping 77 matching lines @@
     }
   }
 
   return FALSE;
 }
 
 // static
 void DownloadItemGtk::OnShelfResized(GtkWidget *widget,
                                      GtkAllocation *allocation,
                                      DownloadItemGtk* item) {
-  if (item->hbox_->allocation.x + item->hbox_->allocation.width >
+  if (item->hbox_.get()->allocation.x + item->hbox_.get()->allocation.width >
       item->bounding_widget_->allocation.x)
-    gtk_widget_hide(item->hbox_);
+    gtk_widget_hide(item->hbox_.get());
   else
-    gtk_widget_show(item->hbox_);
+    gtk_widget_show(item->hbox_.get());
 }
 
 // static
 gboolean DownloadItemGtk::OnDangerousPromptExpose(GtkWidget* widget,
     GdkEventExpose* event, DownloadItemGtk* item) {
   dangerous_nine_box_->RenderToWidget(widget);
   return FALSE;  // Continue propagation.
 }
 
 // static
 // TODO(estade): here and below, add clickjacking histogram code.
 void DownloadItemGtk::OnDangerousAccept(GtkWidget* button,
                                         DownloadItemGtk* item) {
   item->get_download()->manager()->DangerousDownloadValidated(
       item->get_download());
 }
 
 // static
 void DownloadItemGtk::OnDangerousDecline(GtkWidget* button,
                                          DownloadItemGtk* item) {
   if (item->get_download()->state() == DownloadItem::IN_PROGRESS)
     item->get_download()->Cancel(true);
   item->get_download()->Remove(true);
 }