No need to pass DownloadItemModel ownership.

chrome/browser/ui/gtk/download/download_item_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/download/download_item_gtk.h"
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/debug/trace_event.h"
 #include "base/metrics/histogram.h"
@@ skipping 86 matching lines @@
 
 NineBox* DownloadItemGtk::menu_nine_box_normal_ = NULL;
 NineBox* DownloadItemGtk::menu_nine_box_prelight_ = NULL;
 NineBox* DownloadItemGtk::menu_nine_box_active_ = NULL;
 
 NineBox* DownloadItemGtk::dangerous_nine_box_ = NULL;
 
 using content::DownloadItem;
 
 DownloadItemGtk::DownloadItemGtk(DownloadShelfGtk* parent_shelf,
-                                 DownloadItemModel* download_model)
+                                 DownloadItem* download_item)
     : parent_shelf_(parent_shelf),
       arrow_(NULL),
       menu_showing_(false),
       theme_service_(
           GtkThemeService::GetFrom(parent_shelf->browser()->profile())),
       progress_angle_(download_util::kStartAngleDegrees),
-      download_model_(download_model),
+      download_model_(download_item),
       dangerous_prompt_(NULL),
       dangerous_label_(NULL),
       complete_animation_(this),
       icon_small_(NULL),
       icon_large_(NULL),
       creation_time_(base::Time::Now()),
       download_complete_(false),
       disabled_while_opening_(false),
       weak_ptr_factory_(this) {
   LoadIcon();
@@ skipping 61 matching lines @@
   GtkWidget* shelf_hbox = parent_shelf->GetHBox();
   hbox_.Own(gtk_hbox_new(FALSE, 0));
   g_signal_connect(hbox_.get(), "expose-event",
                    G_CALLBACK(OnHboxExposeThunk), this);
   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_.get(), 0);
 
-  get_download()->AddObserver(this);
+  download()->AddObserver(this);
 
   new_item_animation_.reset(new ui::SlideAnimation(this));
   new_item_animation_->SetSlideDuration(kNewItemAnimationDurationMs);
   gtk_widget_show_all(hbox_.get());
 
-  if (download_model_->IsDangerous()) {
+  if (download_model_.IsDangerous()) {
     // Hide the download item components for now.
     gtk_widget_set_no_show_all(body_.get(), TRUE);
     gtk_widget_set_no_show_all(menu_button_, TRUE);
     gtk_widget_hide(body_.get());
     gtk_widget_hide(menu_button_);
 
     // Create an hbox to hold it all.
     dangerous_hbox_.Own(gtk_hbox_new(FALSE, kDangerousElementPadding));
 
     // Add padding at the beginning and end. The hbox will add padding between
@@ skipping 19 matching lines @@
     // Create the nevermind button.
     GtkWidget* dangerous_decline = gtk_button_new_with_label(
         l10n_util::GetStringUTF8(IDS_DISCARD_DOWNLOAD).c_str());
     g_signal_connect(dangerous_decline, "clicked",
                      G_CALLBACK(OnDangerousDeclineThunk), this);
     gtk_util::CenterWidgetInHBox(dangerous_hbox_.get(), dangerous_decline,
                                  false, 0);
 
     // Create the ok button.
     GtkWidget* dangerous_accept = gtk_button_new_with_label(
-        UTF16ToUTF8(download_model_->GetWarningConfirmButtonText()).c_str());
+        UTF16ToUTF8(download_model_.GetWarningConfirmButtonText()).c_str());
     g_signal_connect(dangerous_accept, "clicked",
                      G_CALLBACK(OnDangerousAcceptThunk), this);
     gtk_util::CenterWidgetInHBox(dangerous_hbox_.get(), dangerous_accept, 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_.get());
     gtk_box_pack_start(GTK_BOX(hbox_.get()), dangerous_prompt_, FALSE, FALSE,
                        0);
     gtk_widget_set_app_paintable(dangerous_prompt_, TRUE);
     gtk_widget_set_redraw_on_allocate(dangerous_prompt_, TRUE);
     g_signal_connect(dangerous_prompt_, "expose-event",
                      G_CALLBACK(OnDangerousPromptExposeThunk), this);
     gtk_widget_show_all(dangerous_prompt_);
   }
 
   registrar_.Add(this, chrome::NOTIFICATION_BROWSER_THEME_CHANGED,
                  content::Source<ThemeService>(theme_service_));
   theme_service_->InitThemesFor(this);
 
   // Set the initial width of the widget to be animated.
-  if (download_model_->IsDangerous()) {
+  if (download_model_.IsDangerous()) {
     gtk_widget_set_size_request(dangerous_hbox_.get(),
                                 dangerous_hbox_start_width_, -1);
   } else {
     gtk_widget_set_size_request(body_.get(), kMinDownloadItemWidth, -1);
   }
 
   new_item_animation_->Show();
 
   complete_animation_.SetTweenType(ui::Tween::LINEAR);
   complete_animation_.SetSlideDuration(kCompleteAnimationDurationMs);
 
   // Update the status text and animation state.
-  OnDownloadUpdated(get_download());
+  OnDownloadUpdated(download());
 }
 
 DownloadItemGtk::~DownloadItemGtk() {
   // First close the menu and then destroy the GtkWidgets. Bug#97724
   if (menu_.get())
     menu_.reset();
 
   StopDownloadProgress();
-  get_download()->RemoveObserver(this);
+  download()->RemoveObserver(this);
 
   // We may free some shelf space for showing more download items.
   parent_shelf_->MaybeShowMoreDownloadItems();
 
   hbox_.Destroy();
   progress_area_.Destroy();
   body_.Destroy();
   dangerous_hbox_.Destroy();
 
   // Make sure this widget has been destroyed and the pointer we hold to it
   // NULLed.
   DCHECK(!status_label_);
 }
 
-void DownloadItemGtk::OnDownloadUpdated(DownloadItem* download) {
-  DCHECK_EQ(download, get_download());
+void DownloadItemGtk::OnDownloadUpdated(DownloadItem* download_item) {
+  DCHECK_EQ(download(), download_item);
 
-  if (dangerous_prompt_ != NULL && !download_model_->IsDangerous()) {
+  if (dangerous_prompt_ != NULL && !download_model_.IsDangerous()) {
     // We have been approved.
     gtk_widget_set_no_show_all(body_.get(), FALSE);
     gtk_widget_set_no_show_all(menu_button_, FALSE);
     gtk_widget_show_all(hbox_.get());
     gtk_widget_destroy(dangerous_prompt_);
     gtk_widget_set_size_request(body_.get(), kBodyWidth, -1);
     dangerous_prompt_ = NULL;
 
     // We may free some shelf space for showing more download items.
     parent_shelf_->MaybeShowMoreDownloadItems();
   }
 
-  if (download->GetUserVerifiedFilePath() != icon_filepath_) {
+  if (download()->GetUserVerifiedFilePath() != icon_filepath_) {
     // Turns out the file path is "Unconfirmed %d.crdownload" for dangerous
     // downloads. When the download is confirmed, the file is renamed on
     // another thread, so reload the icon if the download filename changes.
     LoadIcon();
 
     UpdateTooltip();
   }
 
-  switch (download->GetState()) {
+  switch (download()->GetState()) {
     case DownloadItem::CANCELLED:
       StopDownloadProgress();
       gtk_widget_queue_draw(progress_area_.get());
       break;
     case DownloadItem::INTERRUPTED:
       StopDownloadProgress();
       UpdateTooltip();
 
       complete_animation_.Show();
       break;
     case DownloadItem::COMPLETE:
       // GetAutoOpened() may change after the download's initial transition to
       // COMPLETE, so we check it before the idemopotency shield below.
-      if (download->GetAutoOpened()) {
+      if (download()->GetAutoOpened()) {
         parent_shelf_->RemoveDownloadItem(this);  // This will delete us!
         return;
       }
 
       // We've already handled the completion specific actions; skip
       // doing the non-idempotent ones again.
       if (download_complete_)
         break;
 
       StopDownloadProgress();
 
       // Set up the widget as a drag source.
-      DownloadItemDrag::SetSource(body_.get(), get_download(), icon_large_);
+      DownloadItemDrag::SetSource(body_.get(), download(), icon_large_);
 
       complete_animation_.Show();
       download_complete_ = true;
       break;
     case DownloadItem::IN_PROGRESS:
-      get_download()->IsPaused() ?
+      download()->IsPaused() ?
           StopDownloadProgress() : StartDownloadProgress();
       break;
     default:
       NOTREACHED();
   }
 
-  status_text_ = UTF16ToUTF8(download_model_->GetStatusText());
+  status_text_ = UTF16ToUTF8(download_model_.GetStatusText());
   UpdateStatusLabel(status_text_);
 }
 
-void DownloadItemGtk::OnDownloadDestroyed(DownloadItem* download) {
+void DownloadItemGtk::OnDownloadDestroyed(DownloadItem* download_item) {
+  DCHECK_EQ(download(), download_item);
   parent_shelf_->RemoveDownloadItem(this);
   // This will delete us!
 }
 
 void DownloadItemGtk::AnimationProgressed(const ui::Animation* animation) {
   if (animation == &complete_animation_) {
     gtk_widget_queue_draw(progress_area_.get());
   } else {
     DCHECK(animation == new_item_animation_.get());
-    if (download_model_->IsDangerous()) {
+    if (download_model_.IsDangerous()) {
       int progress = static_cast<int>((dangerous_hbox_full_width_ -
                                        dangerous_hbox_start_width_) *
                                       animation->GetCurrentValue());
       int showing_width = dangerous_hbox_start_width_ + progress;
       gtk_widget_set_size_request(dangerous_hbox_.get(), showing_width, -1);
     } else {
       int showing_width = std::max(kMinDownloadItemWidth,
           static_cast<int>(kBodyWidth * animation->GetCurrentValue()));
       gtk_widget_set_size_request(body_.get(), showing_width, -1);
     }
@@ skipping 25 matching lines @@
       if (arrow_)
         gtk_widget_hide(arrow_);
     }
 
     UpdateNameLabel();
     UpdateStatusLabel(status_text_);
     UpdateDangerWarning();
   }
 }
 
-DownloadItem* DownloadItemGtk::get_download() {
-  return download_model_->download();
-}
-
 // Download progress animation functions.
 
 void DownloadItemGtk::UpdateDownloadProgress() {
   progress_angle_ = (progress_angle_ +
                      download_util::kUnknownIncrementDegrees) %
                     download_util::kMaxDegrees;
   gtk_widget_queue_draw(progress_area_.get());
 }
 
 void DownloadItemGtk::StartDownloadProgress() {
@@ skipping 10 matching lines @@
 
 // Icon loading functions.
 
 void DownloadItemGtk::OnLoadSmallIconComplete(gfx::Image* image) {
   icon_small_ = image;
   gtk_widget_queue_draw(progress_area_.get());
 }
 
 void DownloadItemGtk::OnLoadLargeIconComplete(gfx::Image* image) {
   icon_large_ = image;
-  DownloadItemDrag::SetSource(body_.get(), get_download(), icon_large_);
+  DownloadItemDrag::SetSource(body_.get(), download(), icon_large_);
 }
 
 void DownloadItemGtk::LoadIcon() {
   cancelable_task_tracker_.TryCancelAll();
   IconManager* im = g_browser_process->icon_manager();
-  icon_filepath_ = get_download()->GetUserVerifiedFilePath();
+  icon_filepath_ = download()->GetUserVerifiedFilePath();
   im->LoadIcon(icon_filepath_,
                IconLoader::SMALL,
                base::Bind(&DownloadItemGtk::OnLoadSmallIconComplete,
                           base::Unretained(this)),
                &cancelable_task_tracker_);
   im->LoadIcon(icon_filepath_,
                IconLoader::LARGE,
                base::Bind(&DownloadItemGtk::OnLoadLargeIconComplete,
                           base::Unretained(this)),
                &cancelable_task_tracker_);
 }
 
 void DownloadItemGtk::UpdateTooltip() {
   string16 tooltip_text =
-      download_model_->GetTooltipText(gfx::Font(), kTooltipMaxWidth);
+      download_model_.GetTooltipText(gfx::Font(), kTooltipMaxWidth);
   gtk_widget_set_tooltip_text(body_.get(), UTF16ToUTF8(tooltip_text).c_str());
 }
 
 void DownloadItemGtk::UpdateNameLabel() {
   // 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.
   gfx::Font font = gfx::Font();
   string16 filename;
   if (!disabled_while_opening_) {
     filename = ui::ElideFilename(
-        get_download()->GetFileNameToReportUser(), font, kTextWidth);
+        download()->GetFileNameToReportUser(), font, kTextWidth);
   } else {
     // First, Calculate the download status opening string width.
     string16 status_string =
         l10n_util::GetStringFUTF16(IDS_DOWNLOAD_STATUS_OPENING, string16());
     int status_string_width = font.GetStringWidth(status_string);
     // Then, elide the file name.
     string16 filename_string =
-        ui::ElideFilename(get_download()->GetFileNameToReportUser(), font,
+        ui::ElideFilename(download()->GetFileNameToReportUser(), font,
                           kTextWidth - status_string_width);
     // Last, concat the whole string.
     filename = l10n_util::GetStringFUTF16(IDS_DOWNLOAD_STATUS_OPENING,
                                                  filename_string);
   }
 
   GdkColor color = theme_service_->GetGdkColor(
       ThemeService::COLOR_BOOKMARK_TEXT);
   gtk_util::SetLabelColor(
       name_label_,
@@ skipping 58 matching lines @@
   gtk_label_set_text(GTK_LABEL(status_label_), status_text.c_str());
 }
 
 void DownloadItemGtk::UpdateDangerWarning() {
   if (dangerous_prompt_) {
     UpdateDangerIcon();
 
     // We create |dangerous_warning| as a wide string so we can more easily
     // calculate its length in characters.
     string16 dangerous_warning =
-        download_model_->GetWarningText(gfx::Font(), kTextWidth);
+        download_model_.GetWarningText(gfx::Font(), kTextWidth);
     if (theme_service_->UsingNativeTheme()) {
       gtk_util::SetLabelColor(dangerous_label_, NULL);
     } else {
       GdkColor color = theme_service_->GetGdkColor(
           ThemeService::COLOR_BOOKMARK_TEXT);
       gtk_util::SetLabelColor(dangerous_label_, &color);
     }
 
     gtk_label_set_text(GTK_LABEL(dangerous_label_),
                        UTF16ToUTF8(dangerous_warning).c_str());
@@ skipping 26 matching lines @@
     // The width will depend on the text. We must do this each time we possibly
     // change the label above.
     gtk_widget_size_request(dangerous_hbox_.get(), &req);
     dangerous_hbox_full_width_ = req.width;
     dangerous_hbox_start_width_ = dangerous_hbox_full_width_ - label_width;
   }
 }
 
 void DownloadItemGtk::UpdateDangerIcon() {
   if (theme_service_->UsingNativeTheme()) {
-    const char* stock = download_model_->IsMalicious() ?
+    const char* stock = download_model_.IsMalicious() ?
         GTK_STOCK_DIALOG_ERROR : GTK_STOCK_DIALOG_WARNING;
     gtk_image_set_from_stock(
         GTK_IMAGE(dangerous_image_), stock, GTK_ICON_SIZE_SMALL_TOOLBAR);
   } else {
     // Set the warning icon.
     ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
-    int pixbuf_id = download_model_->IsMalicious() ? IDR_SAFEBROWSING_WARNING
-                                                   : IDR_WARNING;
+    int pixbuf_id = download_model_.IsMalicious() ? IDR_SAFEBROWSING_WARNING
+                                                  : IDR_WARNING;
     gtk_image_set_from_pixbuf(GTK_IMAGE(dangerous_image_),
                               rb.GetNativeImageNamed(pixbuf_id).ToGdkPixbuf());
   }
 }
 
 // static
 void DownloadItemGtk::InitNineBoxes() {
   if (body_nine_box_normal_)
     return;
 
@@ skipping 61 matching lines @@
   TRACE_EVENT0("ui::gtk", "DownloadItemGtk::OnHboxExpose");
   if (theme_service_->UsingNativeTheme()) {
     GtkAllocation allocation;
     gtk_widget_get_allocation(widget, &allocation);
     int border_width = gtk_container_get_border_width(GTK_CONTAINER(widget));
     int x = allocation.x + border_width;
     int y = allocation.y + border_width;
     int width = allocation.width - border_width * 2;
     int height = allocation.height - border_width * 2;
 
-    if (download_model_->IsDangerous()) {
+    if (download_model_.IsDangerous()) {
       // Draw a simple frame around the area when we're displaying the warning.
       gtk_paint_shadow(gtk_widget_get_style(widget),
                        gtk_widget_get_window(widget),
                        gtk_widget_get_state(widget),
                        static_cast<GtkShadowType>(GTK_SHADOW_OUT),
                        &e->area, widget, "frame",
                        x, y, width, height);
     } else {
       // Manually draw the GTK button border around the download item. We draw
       // the left part of the button (the file), a divider, and then the right
@@ skipping 90 matching lines @@
       base::Bind(&DownloadItemGtk::ReenableHbox,
                  weak_ptr_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(kDisabledOnOpenDurationMs));
   UpdateNameLabel();
   parent_shelf_->ItemOpened();
 }
 
 void DownloadItemGtk::OnClick(GtkWidget* widget) {
   UMA_HISTOGRAM_LONG_TIMES("clickjacking.open_download",
                            base::Time::Now() - creation_time_);
-  get_download()->OpenDownload();
+  download()->OpenDownload();
 }
 
 gboolean DownloadItemGtk::OnButtonPress(GtkWidget* button,
                                         GdkEventButton* event) {
   if (event->type == GDK_BUTTON_PRESS && event->button == 3) {
     ShowPopupMenu(NULL, event);
     return TRUE;
   }
   return FALSE;
 }
 
 gboolean DownloadItemGtk::OnProgressAreaExpose(GtkWidget* widget,
                                                GdkEventExpose* event) {
   TRACE_EVENT0("ui::gtk", "DownloadItemGtk::OnProgressAreaExpose");
 
   GtkAllocation allocation;
   gtk_widget_get_allocation(widget, &allocation);
 
   // Create a transparent canvas.
   gfx::CanvasSkiaPaint canvas(event, false);
   if (complete_animation_.is_animating()) {
-    if (get_download()->IsInterrupted()) {
+    if (download()->IsInterrupted()) {
       download_util::PaintDownloadInterrupted(&canvas,
           allocation.x, allocation.y,
           complete_animation_.GetCurrentValue(),
           download_util::SMALL);
     } else {
       download_util::PaintDownloadComplete(&canvas,
           allocation.x, allocation.y,
           complete_animation_.GetCurrentValue(),
           download_util::SMALL);
     }
-  } else if (get_download()->IsInProgress()) {
+  } else if (download()->IsInProgress()) {
     download_util::PaintDownloadProgress(&canvas,
         allocation.x, allocation.y,
         progress_angle_,
-        download_model_->PercentComplete(),
+        download_model_.PercentComplete(),
         download_util::SMALL);
   }
 
   // |icon_small_| may be NULL if it is still loading. If the file is an
   // unrecognized type then we will get back a generic system icon. Hence
   // there is no need to use the chromium-specific default download item icon.
   if (icon_small_) {
     const int offset = download_util::kSmallProgressIconOffset;
     canvas.DrawImageInt(icon_small_->AsImageSkia(),
         allocation.x + offset, allocation.y + offset);
@@ skipping 13 matching lines @@
   return FALSE;
 }
 
 void DownloadItemGtk::ShowPopupMenu(GtkWidget* button,
                                     GdkEventButton* event) {
   // Stop any completion animation.
   if (complete_animation_.is_animating())
     complete_animation_.End();
 
   if (!menu_.get()) {
-    menu_.reset(new DownloadShelfContextMenuGtk(download_model_.get(),
-                                                this,
+    menu_.reset(new DownloadShelfContextMenuGtk(this,
                                                 parent_shelf_->GetNavigator()));
   }
   menu_->Popup(button, event);
 }
 
 gboolean DownloadItemGtk::OnDangerousPromptExpose(GtkWidget* widget,
                                                   GdkEventExpose* event) {
   TRACE_EVENT0("ui::gtk", "DownloadItemGtk::OnDangerousPromptExpose");
   if (!theme_service_->UsingNativeTheme()) {
     // The hbox renderer will take care of the border when in GTK mode.
     dangerous_nine_box_->RenderToWidget(widget);
   }
   return FALSE;  // Continue propagation.
 }
 
 void DownloadItemGtk::OnDangerousAccept(GtkWidget* button) {
   UMA_HISTOGRAM_LONG_TIMES("clickjacking.save_download",
                            base::Time::Now() - creation_time_);
-  get_download()->DangerousDownloadValidated();
+  download()->DangerousDownloadValidated();
 }
 
 void DownloadItemGtk::OnDangerousDecline(GtkWidget* button) {
   UMA_HISTOGRAM_LONG_TIMES("clickjacking.discard_download",
                            base::Time::Now() - creation_time_);
-  if (get_download()->IsPartialDownload())
-    get_download()->Cancel(true);
-  get_download()->Delete(DownloadItem::DELETE_DUE_TO_USER_DISCARD);
+  if (download()->IsPartialDownload())
+    download()->Cancel(true);
+  download()->Delete(DownloadItem::DELETE_DUE_TO_USER_DISCARD);
 }