No need to pass DownloadItemModel ownership.

chrome/browser/ui/views/download/download_item_view.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/views/download/download_item_view.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 64 matching lines @@
 // downloaded item.
 static const int kDisabledOnOpenDuration = 3000;
 
 // Darken light-on-dark download status text by 20% before drawing, thus
 // creating a "muted" version of title text for both dark-on-light and
 // light-on-dark themes.
 static const double kDownloadItemLuminanceMod = 0.8;
 
 using content::DownloadItem;
 
-DownloadItemView::DownloadItemView(DownloadItem* download,
-    DownloadShelfView* parent,
-    DownloadItemModel* model)
+DownloadItemView::DownloadItemView(DownloadItem* download_item,
+    DownloadShelfView* parent)
   : warning_icon_(NULL),
-    download_(download),
     shelf_(parent),
     status_text_(l10n_util::GetStringUTF16(IDS_DOWNLOAD_STATUS_STARTING)),
     body_state_(NORMAL),
     drop_down_state_(NORMAL),
     mode_(NORMAL_MODE),
     progress_angle_(download_util::kStartAngleDegrees),
     drop_down_pressed_(false),
     dragging_(false),
     starting_drag_(false),
-    model_(model),
+    model_(download_item),
     save_button_(NULL),
     discard_button_(NULL),
     dangerous_download_label_(NULL),
     dangerous_download_label_sized_(false),
     disabled_while_opening_(false),
     creation_time_(base::Time::Now()),
     ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
-  DCHECK(download_);
-  download_->AddObserver(this);
+  DCHECK(download());
+  download()->AddObserver(this);
   set_context_menu_controller(this);
 
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
 
   BodyImageSet normal_body_image_set = {
     rb.GetImageSkiaNamed(IDR_DOWNLOAD_BUTTON_LEFT_TOP),
     rb.GetImageSkiaNamed(IDR_DOWNLOAD_BUTTON_LEFT_MIDDLE),
     rb.GetImageSkiaNamed(IDR_DOWNLOAD_BUTTON_LEFT_BOTTOM),
     rb.GetImageSkiaNamed(IDR_DOWNLOAD_BUTTON_CENTER_TOP),
     rb.GetImageSkiaNamed(IDR_DOWNLOAD_BUTTON_CENTER_MIDDLE),
@@ skipping 78 matching lines @@
   if (download_util::kSmallProgressIconSize > box_height_)
     box_y_ = (download_util::kSmallProgressIconSize - box_height_) / 2;
   else
     box_y_ = 0;
 
   body_hover_animation_.reset(new ui::SlideAnimation(this));
   drop_hover_animation_.reset(new ui::SlideAnimation(this));
 
   set_accessibility_focusable(true);
 
-  OnDownloadUpdated(download_);
+  OnDownloadUpdated(download());
   UpdateDropDownButtonPosition();
 }
 
 DownloadItemView::~DownloadItemView() {
   StopDownloadProgress();
-  download_->RemoveObserver(this);
+  download()->RemoveObserver(this);
 }
 
 // Progress animation handlers.
 
 void DownloadItemView::UpdateDownloadProgress() {
   progress_angle_ = (progress_angle_ +
                      download_util::kUnknownIncrementDegrees) %
                     download_util::kMaxDegrees;
   SchedulePaint();
 }
@@ skipping 12 matching lines @@
 
 void DownloadItemView::OnExtractIconComplete(gfx::Image* icon_bitmap) {
   if (icon_bitmap)
     shelf_->SchedulePaint();
 }
 
 // DownloadObserver interface.
 
 // Update the progress graphic on the icon and our text status label
 // to reflect our current bytes downloaded, time remaining.
-void DownloadItemView::OnDownloadUpdated(DownloadItem* download) {
-  DCHECK_EQ(download_, download);
+void DownloadItemView::OnDownloadUpdated(DownloadItem* download_item) {
+  DCHECK_EQ(download(), download_item);
 
-  if (IsShowingWarningDialog() && !model_->IsDangerous()) {
+  if (IsShowingWarningDialog() && !model_.IsDangerous()) {
     // We have been approved.
     ClearWarningDialog();
-  } else if (!IsShowingWarningDialog() && model_->IsDangerous()) {
+  } else if (!IsShowingWarningDialog() && model_.IsDangerous()) {
     ShowWarningDialog();
     // Force the shelf to layout again as our size has changed.
     shelf_->Layout();
     SchedulePaint();
   } else {
-    string16 status_text = model_->GetStatusText();
-    switch (download_->GetState()) {
+    string16 status_text = model_.GetStatusText();
+    switch (download()->GetState()) {
       case DownloadItem::IN_PROGRESS:
-        download_->IsPaused() ?
+        download()->IsPaused() ?
             StopDownloadProgress() : StartDownloadProgress();
         LoadIconIfItemPathChanged();
         break;
       case DownloadItem::INTERRUPTED:
         StopDownloadProgress();
         complete_animation_.reset(new ui::SlideAnimation(this));
         complete_animation_->SetSlideDuration(kInterruptedAnimationDurationMs);
         complete_animation_->SetTweenType(ui::Tween::LINEAR);
         complete_animation_->Show();
         SchedulePaint();
         LoadIcon();
         break;
       case DownloadItem::COMPLETE:
-        if (download_->GetAutoOpened()) {
+        if (download()->GetAutoOpened()) {
           shelf_->RemoveDownloadView(this);  // This will delete us!
           return;
         }
         StopDownloadProgress();
         complete_animation_.reset(new ui::SlideAnimation(this));
         complete_animation_->SetSlideDuration(kCompleteAnimationDurationMs);
         complete_animation_->SetTweenType(ui::Tween::LINEAR);
         complete_animation_->Show();
         SchedulePaint();
         LoadIcon();
         break;
       case DownloadItem::CANCELLED:
         StopDownloadProgress();
         LoadIcon();
         break;
       default:
         NOTREACHED();
     }
     status_text_ = status_text;
   }
 
-  string16 new_tip = model_->GetTooltipText(font_, kTooltipMaxWidth);
+  string16 new_tip = model_.GetTooltipText(font_, kTooltipMaxWidth);
   if (new_tip != tooltip_text_) {
     tooltip_text_ = new_tip;
     TooltipTextChanged();
   }
 
   UpdateAccessibleName();
 
   // We use the parent's (DownloadShelfView's) SchedulePaint, since there
   // are spaces between each DownloadItemView that the parent is responsible
   // for painting.
@@ skipping 91 matching lines @@
 bool DownloadItemView::OnMouseDragged(const ui::MouseEvent& event) {
   // Mouse should not activate us in dangerous mode.
   if (IsShowingWarningDialog())
     return true;
 
   if (!starting_drag_) {
     starting_drag_ = true;
     drag_start_point_ = event.location();
   }
   if (dragging_) {
-    if (download_->IsComplete()) {
+    if (download()->IsComplete()) {
       IconManager* im = g_browser_process->icon_manager();
-      gfx::Image* icon = im->LookupIcon(download_->GetUserVerifiedFilePath(),
+      gfx::Image* icon = im->LookupIcon(download()->GetUserVerifiedFilePath(),
                                         IconLoader::SMALL);
       if (icon) {
         views::Widget* widget = GetWidget();
-        download_util::DragDownload(download_, icon,
+        download_util::DragDownload(download(), icon,
                                     widget ? widget->GetNativeView() : NULL);
       }
     }
   } else if (ExceededDragThreshold(event.location() - drag_start_point_)) {
     dragging_ = true;
   }
   return true;
 }
 
 void DownloadItemView::OnMouseReleased(const ui::MouseEvent& event) {
@@ skipping 51 matching lines @@
   }
 
   tooltip->assign(tooltip_text_);
 
   return true;
 }
 
 void DownloadItemView::GetAccessibleState(ui::AccessibleViewState* state) {
   state->name = accessible_name_;
   state->role = ui::AccessibilityTypes::ROLE_PUSHBUTTON;
-  if (model_->IsDangerous()) {
+  if (model_.IsDangerous()) {
     state->state = ui::AccessibilityTypes::STATE_UNAVAILABLE;
   } else {
     state->state = ui::AccessibilityTypes::STATE_HASPOPUP;
   }
 }
 
 void DownloadItemView::OnThemeChanged() {
   UpdateColorsFromTheme();
 }
 
@@ skipping 20 matching lines @@
   gfx::Point local_point = point;
   ConvertPointFromScreen(this, &local_point);
   ShowContextMenuImpl(local_point, true);
 }
 
 void DownloadItemView::ButtonPressed(
     views::Button* sender, const ui::Event& event) {
   if (sender == discard_button_) {
     UMA_HISTOGRAM_LONG_TIMES("clickjacking.discard_download",
                              base::Time::Now() - creation_time_);
-    if (download_->IsPartialDownload())
-      download_->Cancel(true);
-    download_->Delete(DownloadItem::DELETE_DUE_TO_USER_DISCARD);
+    if (download()->IsPartialDownload())
+      download()->Cancel(true);
+    download()->Delete(DownloadItem::DELETE_DUE_TO_USER_DISCARD);
     // WARNING: we are deleted at this point.  Don't access 'this'.
   } else if (save_button_ && sender == save_button_) {
     // The user has confirmed a dangerous download.  We'd record how quickly the
     // user did this to detect whether we're being clickjacked.
     UMA_HISTOGRAM_LONG_TIMES("clickjacking.save_download",
                              base::Time::Now() - creation_time_);
     // This will change the state and notify us.
-    download_->DangerousDownloadValidated();
+    download()->DangerousDownloadValidated();
   }
 }
 
 void DownloadItemView::AnimationProgressed(const ui::Animation* animation) {
   // We don't care if what animation (body button/drop button/complete),
   // is calling back, as they all have to go through the same paint call.
   SchedulePaint();
 }
 
 // The DownloadItemView can be in three major modes (NORMAL_MODE, DANGEROUS_MODE
@@ skipping 186 matching lines @@
   // Consequently, the x-axis of following canvas->DrawXXX() method should be
   // mirrored so the text and images are down in the right positions.
   canvas->Restore();
 
   // Print the text, left aligned and always print the file extension.
   // Last value of x was the end of the right image, just before the button.
   // Note that in dangerous mode we use a label (as the text is multi-line).
   if (!IsShowingWarningDialog()) {
     string16 filename;
     if (!disabled_while_opening_) {
-      filename = ui::ElideFilename(download_->GetFileNameToReportUser(),
+      filename = ui::ElideFilename(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(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);
     }
 
     int mirrored_x = GetMirroredXWithWidthInView(
         download_util::kSmallProgressIconSize, kTextWidth);
     SkColor file_name_color = GetThemeProvider()->GetColor(
         ThemeService::COLOR_BOOKMARK_TEXT);
     int y =
         box_y_ + (status_text_.empty() ?
                   ((box_height_ - font_.GetHeight()) / 2) : kVerticalPadding);
 
     // Draw the file's name.
     canvas->DrawStringInt(filename, font_,
                           enabled() ? file_name_color
                                     : kFileNameDisabledColor,
                           mirrored_x, y, kTextWidth, font_.GetHeight());
   }
 
   // Load the icon.
   IconManager* im = g_browser_process->icon_manager();
-  gfx::Image* image = im->LookupIcon(download_->GetUserVerifiedFilePath(),
+  gfx::Image* image = im->LookupIcon(download()->GetUserVerifiedFilePath(),
                                      IconLoader::SMALL);
   const gfx::ImageSkia* icon = NULL;
   if (IsShowingWarningDialog())
     icon = warning_icon_;
   else if (image)
     icon = image->ToImageSkia();
 
   // We count on the fact that the icon manager will cache the icons and if one
   // is available, it will be cached here. We *don't* want to request the icon
   // to be loaded here, since this will also get called if the icon can't be
   // loaded, in which case LookupIcon will always be NULL. The loading will be
   // triggered only when we think the status might change.
   if (icon) {
     if (!IsShowingWarningDialog()) {
-      if (download_->IsInProgress()) {
+      if (download()->IsInProgress()) {
         download_util::PaintDownloadProgress(canvas, this, 0, 0,
                                              progress_angle_,
-                                             model_->PercentComplete(),
+                                             model_.PercentComplete(),
                                              download_util::SMALL);
-      } else if (download_->IsComplete() &&
+      } else if (download()->IsComplete() &&
                  complete_animation_.get() &&
                  complete_animation_->is_animating()) {
-        if (download_->IsInterrupted()) {
+        if (download()->IsInterrupted()) {
           download_util::PaintDownloadInterrupted(canvas, this, 0, 0,
               complete_animation_->GetCurrentValue(),
               download_util::SMALL);
         } else {
           download_util::PaintDownloadComplete(canvas, this, 0, 0,
               complete_animation_->GetCurrentValue(),
               download_util::SMALL);
         }
       }
     }
@@ skipping 19 matching lines @@
     }
   }
 }
 
 void DownloadItemView::OpenDownload() {
   DCHECK(!IsShowingWarningDialog());
   // We're interested in how long it takes users to open downloads.  If they
   // open downloads super quickly, we should be concerned about clickjacking.
   UMA_HISTOGRAM_LONG_TIMES("clickjacking.open_download",
                            base::Time::Now() - creation_time_);
-  download_->OpenDownload();
+  download()->OpenDownload();
   UpdateAccessibleName();
 }
 
 void DownloadItemView::LoadIcon() {
   IconManager* im = g_browser_process->icon_manager();
-  last_download_item_path_ = download_->GetUserVerifiedFilePath();
+  last_download_item_path_ = download()->GetUserVerifiedFilePath();
   im->LoadIcon(last_download_item_path_,
                IconLoader::SMALL,
                base::Bind(&DownloadItemView::OnExtractIconComplete,
                           base::Unretained(this)),
                &cancelable_task_tracker_);
 }
 
 void DownloadItemView::LoadIconIfItemPathChanged() {
-  FilePath current_download_path = download_->GetUserVerifiedFilePath();
+  FilePath current_download_path = download()->GetUserVerifiedFilePath();
   if (last_download_item_path_ == current_download_path)
     return;
 
   LoadIcon();
 }
 
 void DownloadItemView::UpdateColorsFromTheme() {
   if (dangerous_download_label_ && GetThemeProvider()) {
     dangerous_download_label_->SetEnabledColor(
         GetThemeProvider()->GetColor(ThemeService::COLOR_BOOKMARK_TEXT));
@@ skipping 28 matching lines @@
   // below, it runs an inner message loop that might cause us to be deleted.
   // Posting a task with a WeakPtr lets us safely handle the button release.
   MessageLoop::current()->PostNonNestableTask(
       FROM_HERE,
       base::Bind(&DownloadItemView::ReleaseDropDown,
                  weak_ptr_factory_.GetWeakPtr()));
   views::View::ConvertPointToScreen(this, &point);
 
   if (!context_menu_.get()) {
     context_menu_.reset(
-        new DownloadShelfContextMenuView(model_.get(),
-                                         shelf_->GetNavigator()));
+        new DownloadShelfContextMenuView(download(), shelf_->GetNavigator()));
   }
   context_menu_->Run(GetWidget()->GetTopLevelWidget(),
                      gfx::Rect(point, size));
   // We could be deleted now.
 }
 
 void DownloadItemView::HandlePressEvent(const ui::LocatedEvent& event,
                                         bool active_event) {
   // The event should not activate us in dangerous mode.
   if (mode_ == DANGEROUS_MODE)
@@ skipping 76 matching lines @@
   AnimateStateTransition(body_state_, new_body_state,
                          body_hover_animation_.get());
   AnimateStateTransition(drop_down_state_, new_drop_state,
                          drop_hover_animation_.get());
   body_state_ = new_body_state;
   drop_down_state_ = new_drop_state;
   SchedulePaint();
 }
 
 void DownloadItemView::ClearWarningDialog() {
-  DCHECK(download_->GetSafetyState() == DownloadItem::DANGEROUS_BUT_VALIDATED &&
-         (mode_ == DANGEROUS_MODE || mode_ == MALICIOUS_MODE));
+  DCHECK(download()->GetSafetyState() == DownloadItem::DANGEROUS_BUT_VALIDATED);
+  DCHECK(mode_ == DANGEROUS_MODE || mode_ == MALICIOUS_MODE);
 
   mode_ = NORMAL_MODE;
   body_state_ = NORMAL;
   drop_down_state_ = NORMAL;
 
   // Remove the views used by the warning dialog.
   if (save_button_) {
     RemoveChildView(save_button_);
     delete save_button_;
     save_button_ = NULL;
   }
   RemoveChildView(discard_button_);
   delete discard_button_;
   discard_button_ = NULL;
   RemoveChildView(dangerous_download_label_);
   delete dangerous_download_label_;
   dangerous_download_label_ = NULL;
   dangerous_download_label_sized_ = false;
   cached_button_size_.SetSize(0,0);
 
   // Set the accessible name back to the status and filename instead of the
   // download warning.
   UpdateAccessibleName();
   UpdateDropDownButtonPosition();
 
-  // We need to load the icon now that the download_ has the real path.
+  // We need to load the icon now that the download has the real path.
   LoadIcon();
 
   // Force the shelf to layout again as our size has changed.
   shelf_->Layout();
   shelf_->SchedulePaint();
 
   TooltipTextChanged();
 }
 
 void DownloadItemView::ShowWarningDialog() {
   DCHECK(mode_ != DANGEROUS_MODE && mode_ != MALICIOUS_MODE);
-  mode_ = ((model_->IsMalicious()) ? MALICIOUS_MODE : DANGEROUS_MODE);
+  mode_ = ((model_.IsMalicious()) ? MALICIOUS_MODE : DANGEROUS_MODE);
 
   body_state_ = NORMAL;
   drop_down_state_ = NORMAL;
   if (mode_ == DANGEROUS_MODE) {
     save_button_ = new views::NativeTextButton(
-        this, model_->GetWarningConfirmButtonText());
+        this, model_.GetWarningConfirmButtonText());
     save_button_->set_ignore_minimum_size(true);
     AddChildView(save_button_);
   }
   discard_button_ = new views::NativeTextButton(
       this, l10n_util::GetStringUTF16(IDS_DISCARD_DOWNLOAD));
   discard_button_->set_ignore_minimum_size(true);
   AddChildView(discard_button_);
 
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   // The dangerous download label text and icon are different under
   // different cases.
   if (mode_ == MALICIOUS_MODE) {
     warning_icon_ = rb.GetImageSkiaNamed(IDR_SAFEBROWSING_WARNING);
   } else {
     // The download file has dangerous file type (e.g.: an executable).
     warning_icon_ = rb.GetImageSkiaNamed(IDR_WARNING);
   }
-  string16 dangerous_label = model_->GetWarningText(font_, kTextWidth);
+  string16 dangerous_label = model_.GetWarningText(font_, kTextWidth);
   dangerous_download_label_ = new views::Label(dangerous_label);
   dangerous_download_label_->SetMultiLine(true);
   dangerous_download_label_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
   dangerous_download_label_->SetAutoColorReadabilityEnabled(false);
   AddChildView(dangerous_download_label_);
   SizeLabelToMinWidth();
   UpdateDropDownButtonPosition();
   TooltipTextChanged();
 }
 
@@ skipping 101 matching lines @@
     return true;
   return false;
 }
 
 void DownloadItemView::UpdateAccessibleName() {
   string16 new_name;
   if (IsShowingWarningDialog()) {
     new_name = dangerous_download_label_->text();
   } else {
     new_name = status_text_ + char16(' ') +
-        download_->GetFileNameToReportUser().LossyDisplayName();
+        download()->GetFileNameToReportUser().LossyDisplayName();
   }
 
   // If the name has changed, notify assistive technology that the name
   // has changed so they can announce it immediately.
   if (new_name != accessible_name_) {
     accessible_name_ = new_name;
     if (GetWidget()) {
       GetWidget()->NotifyAccessibilityEvent(
           this, ui::AccessibilityTypes::EVENT_NAME_CHANGED, true);
     }
@@ skipping 17 matching lines @@
 void DownloadItemView::AnimateStateTransition(State from, State to,
                                               ui::SlideAnimation* animation) {
   if (from == NORMAL && to == HOT) {
     animation->Show();
   } else if (from == HOT && to == NORMAL) {
     animation->Hide();
   } else if (from != to) {
     animation->Reset((to == HOT) ? 1.0 : 0.0);
   }
 }