Added dangerous download prompting.

chrome/browser/views/download_tab_view.cc

 // Copyright (c) 2006-2008 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/views/download_tab_view.h"
 
 #include <time.h>
 
 #include <algorithm>
 #include <functional>
@@ skipping 12 matching lines @@
 #include "chrome/common/l10n_util.h"
 #include "chrome/common/resource_bundle.h"
 #include "chrome/common/stl_util-inl.h"
 #include "chrome/common/time_format.h"
 #include "chrome/views/background.h"
 #include "googleurl/src/gurl.h"
 #include "generated_resources.h"
 
 // Approximate spacing, in pixels, taken from initial UI mock up screens
 static const int kVerticalPadding = 5;
-static const int kHorizontalButtonPadding = 15;
+static const int kHorizontalLinkPadding = 15;
+static const int kHorizontalButtonPadding = 8;
 
 // For vertical and horizontal element spacing
 static const int kSpacer = 20;
 
 // Horizontal space between the left edge of the entries and the
 // left edge of the view.
 static const int kLeftMargin = 38;
 
 // x-position of the icon (massage this so it visually matches
 // kDestinationSearchOffset in native_ui_contents.cc
@@ skipping 14 matching lines @@
 
 // Status label color (grey)
 static const SkColor kStatusColor = SkColorSetRGB(128, 128, 128);
 
 // URL label color (green)
 static const SkColor kUrlColor = SkColorSetRGB(0, 128, 0);
 
 // Paused download indicator (red)
 static const SkColor kPauseColor = SkColorSetRGB(128, 0, 0);
 
+// Warning label color (blue)
+static const SkColor kWarningColor = SkColorSetRGB(87, 108, 149);
+
 // Selected item background color
 static const SkColor kSelectedItemColor = SkColorSetRGB(215, 232, 255);
 
 // State key used to identify search text.
 static const wchar_t kSearchTextKey[] = L"st";
 
+// The maximum number of characters we show in a file name when displaying the
+// dangerous download message.
+static const int kFileNameMaxLength = 20;
+
 // Sorting functor for DownloadItem --------------------------------------------
 
 // Sort DownloadItems into ascending order by their start time.
 class DownloadItemSorter : public std::binary_function<DownloadItem*,
                                                        DownloadItem*,
                                                        bool> {
  public:
   bool operator()(const DownloadItem* lhs, const DownloadItem* rhs) {
     return lhs->start_time() < rhs->start_time();
   }
 };
 
 
 // DownloadItemTabView implementation ------------------------------------------
 DownloadItemTabView::DownloadItemTabView()
     : model_(NULL),
-      parent_(NULL) {
+      parent_(NULL),
+      is_floating_view_renderer_(false) {
   // Create our element views using empty strings for now,
   // set them based on the model's state in Layout().
   since_ = new ChromeViews::Label(L"");
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
   ChromeFont font = rb.GetFont(ResourceBundle::WebFont);
   since_->SetHorizontalAlignment(ChromeViews::Label::ALIGN_LEFT);
   since_->SetFont(font);
   AddChildView(since_);
 
   date_ = new ChromeViews::Label(L"");
   date_->SetColor(kStatusColor);
   date_->SetHorizontalAlignment(ChromeViews::Label::ALIGN_LEFT);
   date_->SetFont(font);
   AddChildView(date_);
 
   // file_name_ is enabled once the download has finished and we can open
   // it via ShellExecute.
   file_name_ = new ChromeViews::Link(L"");
   file_name_->SetHorizontalAlignment(ChromeViews::Label::ALIGN_LEFT);
   file_name_->SetController(this);
   file_name_->SetFont(font);
   AddChildView(file_name_);
 
+  // dangerous_download_warning_ is enabled when a dangerous download has been
+  // initiated.
+  dangerous_download_warning_ = new ChromeViews::Label();
+  dangerous_download_warning_ ->SetMultiLine(true);
+  dangerous_download_warning_->SetColor(kWarningColor);
+  dangerous_download_warning_->SetHorizontalAlignment(
+      ChromeViews::Label::ALIGN_LEFT);
+  dangerous_download_warning_->SetFont(font);
+  AddChildView(dangerous_download_warning_);
+
+  // The save and discard buttons are shown to prompt the user when a dangerous
+  // download was started.
+  save_button_ = new ChromeViews::NativeButton(
+      l10n_util::GetString(IDS_SAVE_DOWNLOAD));
+  save_button_->set_enforce_dlu_min_size(false);
+  save_button_->SetListener(this);
+  discard_button_ = new ChromeViews::NativeButton(
+      l10n_util::GetString(IDS_DISCARD_DOWNLOAD));
+  discard_button_->SetListener(this);
+  discard_button_->set_enforce_dlu_min_size(false);
+  AddChildView(save_button_);
+  AddChildView(discard_button_);
+
   // Set our URL name
   download_url_ = new ChromeViews::Label(L"");
   download_url_->SetColor(kUrlColor);
   download_url_->SetHorizontalAlignment(ChromeViews::Label::ALIGN_LEFT);
   download_url_->SetFont(font);
   AddChildView(download_url_);
 
   // Set our time remaining
   time_remaining_ = new ChromeViews::Label(L"");
   time_remaining_->SetColor(kStatusColor);
@@ skipping 41 matching lines @@
 void DownloadItemTabView::GetPreferredSize(CSize* out) {
   CSize pause_size;
   pause_->GetPreferredSize(&pause_size);
   CSize cancel_size;
   cancel_->GetPreferredSize(&cancel_size);
   CSize show_size;
   show_->GetPreferredSize(&show_size);
 
   out->cx = download_util::kBigProgressIconSize +
             2 * kSpacer +
-            kHorizontalButtonPadding +
+            kHorizontalLinkPadding +
             kFilenameSize +
-            std::max(pause_size.cx + cancel_size.cx + kHorizontalButtonPadding,
+            std::max(pause_size.cx + cancel_size.cx + kHorizontalLinkPadding,
                      show_size.cx);
 
   out->cy = download_util::kBigProgressIconSize;
 }
 
 // Each DownloadItemTabView has reasonably complex layout requirements
 // that are based on the state of its model. To make the code much simpler
 // to read, Layout() is split into state specific code which will result
 // in some redundant code.
 void DownloadItemTabView::Layout() {
   DCHECK(model_);
   switch (model_->state()) {
     case DownloadItem::COMPLETE:
-      LayoutComplete();
+      if (model_->safety_state() == DownloadItem::DANGEROUS)
+        LayoutPromptDangerousDownload();
+      else
+        LayoutComplete();
       break;
     case DownloadItem::CANCELLED:
       LayoutCancelled();
       break;
     case DownloadItem::IN_PROGRESS:
-      LayoutInProgress();
+      if (model_->safety_state() == DownloadItem::DANGEROUS)
+        LayoutPromptDangerousDownload();
+      else
+        LayoutInProgress();
       break;
     case DownloadItem::REMOVING:
       break;
     default:
       NOTREACHED();
   }
 }
 
 // Only display the date if the download is the last that occurred
 // on a given day.
@@ skipping 23 matching lines @@
 
 // DownloadItem::COMPLETE state layout
 void DownloadItemTabView::LayoutComplete() {
   // Hide unused UI elements
   pause_->SetVisible(false);
   pause_->SetEnabled(false);
   cancel_->SetVisible(false);
   cancel_->SetEnabled(false);
   time_remaining_->SetVisible(false);
   download_progress_->SetVisible(false);
+  dangerous_download_warning_->SetVisible(false);
+  save_button_->SetVisible(false);
+  save_button_->SetEnabled(false);
+  discard_button_->SetVisible(false);
+  discard_button_->SetEnabled(false);
 
   LayoutDate();
   int dx = kDownloadIconOffset - download_util::kBigProgressIconOffset +
            download_util::kBigProgressIconSize + kInfoPadding;
 
   // File name and URL
   CSize file_name_size;
   file_name_->SetText(model_->file_name());
   file_name_->GetPreferredSize(&file_name_size);
   file_name_->SetBounds(dx, download_util::kBigProgressIconOffset,
@@ skipping 28 matching lines @@
 
 // DownloadItem::CANCELLED state layout
 void DownloadItemTabView::LayoutCancelled() {
   // Hide unused UI elements
   show_->SetVisible(false);
   show_->SetEnabled(false);
   pause_->SetVisible(false);
   pause_->SetEnabled(false);
   cancel_->SetVisible(false);
   cancel_->SetEnabled(false);
+  dangerous_download_warning_->SetVisible(false);
+  save_button_->SetVisible(false);
+  save_button_->SetEnabled(false);
+  discard_button_->SetVisible(false);
+  discard_button_->SetEnabled(false);
 
   LayoutDate();
   int dx = kDownloadIconOffset - download_util::kBigProgressIconOffset +
       download_util::kBigProgressIconSize + kInfoPadding;
 
   // File name and URL, truncated to show cancelled status
   CSize file_name_size;
   file_name_->SetText(model_->file_name());
   file_name_->GetPreferredSize(&file_name_size);
   file_name_->SetBounds(dx, download_util::kBigProgressIconOffset,
@@ skipping 66 matching lines @@
                                 kProgressSize,
                                 byte_size.cy);
   download_progress_->SetVisible(true);
 }
 
 // DownloadItem::IN_PROGRESS state layout
 void DownloadItemTabView::LayoutInProgress() {
   // Hide unused UI elements
   show_->SetVisible(false);
   show_->SetEnabled(false);
+  dangerous_download_warning_->SetVisible(false);
+  save_button_->SetVisible(false);
+  save_button_->SetEnabled(false);
+  discard_button_->SetVisible(false);
+  discard_button_->SetEnabled(false);
 
   LayoutDate();
   int dx = kDownloadIconOffset - download_util::kBigProgressIconOffset +
             download_util::kBigProgressIconSize +
            kInfoPadding;
 
   // File name and URL, truncated to show progress status
   CSize file_name_size;
-  file_name_->SetText(model_->file_name());
+  file_name_->SetText(model_->GetFileName());
   file_name_->GetPreferredSize(&file_name_size);
   file_name_->SetBounds(dx, download_util::kBigProgressIconOffset,
                         kFilenameSize - kProgressSize - kSpacer,
                         file_name_size.cy);
   file_name_->SetVisible(true);
   file_name_->SetEnabled(false);
 
   GURL url(model_->url());
   download_url_->SetURL(url);
   CSize url_size;
@@ skipping 113 matching lines @@
     pause_->SetText(l10n_util::GetString(IDS_DOWNLOAD_LINK_RESUME));
   else
     pause_->SetText(l10n_util::GetString(IDS_DOWNLOAD_LINK_PAUSE));
 
   CSize pause_size;
   pause_->SetVisible(true);
   pause_->SetEnabled(true);
   pause_->GetPreferredSize(&pause_size);
   pause_->SetBounds(dx, y_pos, pause_size.cx, pause_size.cy);
 
-  dx += pause_size.cx + kHorizontalButtonPadding;
+  dx += pause_size.cx + kHorizontalLinkPadding;
 
   CSize cancel_size;
   cancel_->GetPreferredSize(&cancel_size);
   cancel_->SetBounds(dx, y_pos, cancel_size.cx, cancel_size.cy);
   cancel_->SetVisible(true);
   cancel_->SetEnabled(true);
 }
 
+void DownloadItemTabView::LayoutPromptDangerousDownload() {
+  // Hide unused UI elements
+  show_->SetVisible(false);
+  show_->SetEnabled(false);
+  file_name_->SetVisible(false);
+  file_name_->SetEnabled(false);
+  pause_->SetVisible(false);
+  pause_->SetEnabled(false);
+  cancel_->SetVisible(false);
+  cancel_->SetEnabled(false);
+  time_remaining_->SetVisible(false);
+  download_progress_->SetVisible(false);
+
+  LayoutDate();
+  int dx = kDownloadIconOffset - download_util::kBigProgressIconOffset +
+           download_util::kBigProgressIconSize +
+           kInfoPadding;
+
+  // Warning message and URL.
+  CSize warning_size;
+  std::wstring file_name;
+  ElideString(model_->original_name(), kFileNameMaxLength, &file_name);
+  dangerous_download_warning_->SetText(
+      l10n_util::GetStringF(IDS_PROMPT_DANGEROUS_DOWNLOAD, file_name));
+  dangerous_download_warning_->GetPreferredSize(&warning_size);
+  dangerous_download_warning_->SetBounds(dx, 0,
+                                         kFilenameSize, warning_size.cy);
+  dangerous_download_warning_->SetVisible(true);
+
+  GURL url(model_->url());
+  download_url_->SetURL(url);
+  CSize url_size;
+  download_url_->GetPreferredSize(&url_size);
+  download_url_->SetBounds(dx, height() - url_size.cy,
+                           std::min(kFilenameSize - kSpacer,
+                                    static_cast<int>(width() - dx)),
+                           url_size.cy);
+  download_url_->SetVisible(true);
+
+  dx += kFilenameSize + kSpacer;
+
+  // Save/Discard buttons.
+  CSize button_size;
+  save_button_->GetPreferredSize(&button_size);
+  save_button_->SetBounds(dx, (height() - button_size.cy) / 2,
+                          button_size.cx, button_size.cy);
+  save_button_->SetVisible(true);
+  save_button_->SetEnabled(true);
+
+  dx += button_size.cx + kHorizontalButtonPadding;
+
+  discard_button_->GetPreferredSize(&button_size);
+  discard_button_->SetBounds(dx, (height() - button_size.cy) / 2,
+                             button_size.cx, button_size.cy);
+  discard_button_->SetVisible(true);
+  discard_button_->SetEnabled(true);
+}
+
 void DownloadItemTabView::Paint(ChromeCanvas* canvas) {
   PaintBackground(canvas);
 
-  if (model_->state() == DownloadItem::IN_PROGRESS) {
+  if (model_->state() == DownloadItem::IN_PROGRESS  &&
+      model_->safety_state() != DownloadItem::DANGEROUS) {
     download_util::PaintDownloadProgress(canvas,
                                          this,
                                          kDownloadIconOffset -
                                          download_util::kBigProgressIconOffset,
                                          0,
                                          parent_->start_angle(),
                                          model_->PercentComplete(),
                                          download_util::BIG);
   }
 
@@ skipping 58 matching lines @@
                     download_util::kBigProgressIconSize);
 
   // The position of the highlighted region does not take into account the
   // View's UI layout so we have to manually mirror the position if the View is
   // using a right-to-left UI layout.
   gfx::Rect mirrored_rect(select_rect);
   select_rect.MoveToX(MirroredLeftPointForRect(mirrored_rect));
   if (select_rect.PtInRect(point)) {
     parent_->ItemBecameSelected(model_);
 
-    if (event.IsRightMouseButton()) {
+    // Don't show the right-click menu if we are prompting the user for a
+    // dangerous download.
+    if (event.IsRightMouseButton() &&
+        model_->safety_state() != DownloadItem::DANGEROUS) {
       ChromeViews::View::ConvertPointToScreen(this, &point);
 
       download_util::DownloadDestinationContextMenu menu(
           model_, GetViewContainer()->GetHWND(), point);
     }
   } else {
     parent_->ItemBecameSelected(NULL);
   }
 
   return true;
 }
 
 // Handle drag (file copy) operations.
 bool DownloadItemTabView::OnMouseDragged(const ChromeViews::MouseEvent& event) {
-  if (model_->state() != DownloadItem::COMPLETE)
+  if (model_->state() != DownloadItem::COMPLETE ||
+      model_->safety_state() == DownloadItem::DANGEROUS)
     return false;
 
   CPoint point(event.x(), event.y());
 
   // In order to make sure drag and drop works as expected when the UI is
   // mirrored, we can either flip the mouse X coordinate or flip the X position
   // of the drag rectangle. Flipping the mouse X coordinate is easier.
   point.x = MirroredXCoordinateInsideView(point.x);
   CRect drag_rect(kDownloadIconOffset - download_util::kBigProgressIconOffset,
                   0,
@@ skipping 24 matching lines @@
     model_->Cancel(true /* update history service */);
   } else if (source == show_) {
     model_->manager()->ShowDownloadInShell(model_);
   } else {
     NOTREACHED();
   }
 
   parent_->ItemBecameSelected(model_);
 }
 
+void DownloadItemTabView::ButtonPressed(ChromeViews::NativeButton* sender) {
+  if (sender == save_button_) {
+    parent_->model()->DangerousDownloadValidated(model_);
+    // Relayout and repaint to display the right mode (complete or in progress).
+    Layout();
+    SchedulePaint();
+  } else if (sender == discard_button_) {
+    model_->Remove(true);
+  } else  {
+    NOTREACHED();
+  }
+}
 
 // DownloadTabView implementation ----------------------------------------------
 
 DownloadTabView::DownloadTabView(DownloadManager* model)
     : model_(model),
       start_angle_(download_util::kStartAngleDegrees),
       scroll_helper_(kSpacer, download_util::kBigProgressIconSize + kSpacer),
       selected_index_(-1) {
   DCHECK(model_);
 }
 
 DownloadTabView::~DownloadTabView() {
   StopDownloadProgress();
   model_->RemoveObserver(this);
 
   // DownloadManager owns the contents.
   downloads_.clear();
   ClearDownloadInProgress();
+  ClearDangerousDownloads();
 
   icon_consumer_.CancelAllRequests();
 }
 
 void DownloadTabView::Initialize() {
   model_->AddObserver(this);
 }
 
 // Start progress animation timers when we get our first (in-progress) download.
 void DownloadTabView::StartDownloadProgress() {
@@ skipping 17 matching lines @@
 }
 
 void DownloadTabView::DidChangeBounds(const CRect& previous,
                                       const CRect& current) {
   Layout();
 }
 
 void DownloadTabView::Layout() {
   CRect r;
   DetachAllFloatingViews();
+  // Dangerous downloads items use NativeButtons, so they need to be attached
+  // as NativeControls are not supported yet in floating views.
+  gfx::Rect visible_bounds = GetVisibleBounds();
+  int row_start = (visible_bounds.y() - kSpacer) /
+                  (download_util::kBigProgressIconSize + kSpacer);
+  int row_stop = (visible_bounds.y() - kSpacer + visible_bounds.height()) /
+                 (download_util::kBigProgressIconSize + kSpacer);
+  row_stop = std::min(row_stop, static_cast<int>(downloads_.size()) - 1);
+  for (int i = row_start; i <= row_stop; ++i) {
+    // The DownloadManager stores downloads earliest first, but this view
+    // displays latest first, so adjust the index:
+    int index = static_cast<int>(downloads_.size()) - 1 - i;
+    if (downloads_[index]->safety_state() == DownloadItem::DANGEROUS)
+      ValidateFloatingViewForID(index);
+  }
   View* v = GetParent();
   if (v) {
     v->GetLocalBounds(&r, true);
     int h = static_cast<int>(downloads_.size()) *
             (download_util::kBigProgressIconSize + kSpacer) + kSpacer;
     SetBounds(x(), y(), v->width(), h);
   }
 }
 
 // Paint our scrolled region
@@ skipping 50 matching lines @@
 }
 
 ChromeViews::View* DownloadTabView::CreateFloatingViewForIndex(int index) {
   if (index >= static_cast<int>(downloads_.size())) {
     // It's possible that the downloads have been cleared via the "Clear
     // Browsing Data" command, so this index is gone.
     return NULL;
   }
 
   DownloadItemTabView* dl = new DownloadItemTabView();
+  // We attach the view before layout as the Save/Discard buttons are native
+  // and need to be in the tree hierarchy to compute their preferred size
+  // correctly.
+  AttachFloatingView(dl, index);
   dl->SetModel(downloads_[index], this);
   int row = static_cast<int>(downloads_.size()) - 1 - index;
   int y_pos = row * (download_util::kBigProgressIconSize + kSpacer) + kSpacer;
   dl->SetBounds(0, y_pos, width(), download_util::kBigProgressIconSize);
   dl->Layout();
-  AttachFloatingView(dl, index);
   return dl;
 }
 
 bool DownloadTabView::EnumerateFloatingViews(
       ChromeViews::View::FloatingViewPosition position,
       int starting_id, int* id) {
   DCHECK(id);
   return View::EnumerateFloatingViewsForInterval(
       0, static_cast<int>(downloads_.size()), false, position, starting_id, id);
 }
 
 ChromeViews::View* DownloadTabView::ValidateFloatingViewForID(int id) {
   return CreateFloatingViewForIndex(id);
 }
 
 void DownloadTabView::OnDownloadUpdated(DownloadItem* download) {
   switch (download->state()) {
     case DownloadItem::COMPLETE:
     case DownloadItem::CANCELLED: {
       base::hash_set<DownloadItem*>::iterator d = in_progress_.find(download);
       if (d != in_progress_.end()) {
-        (*d)->RemoveObserver(this);
+        // If this is a dangerous download not yet validated by the user, we
+        // still need to be notified when the validation happens.
+        if (download->safety_state() != DownloadItem::DANGEROUS)
+          (*d)->RemoveObserver(this);
         in_progress_.erase(d);
       }
       if (in_progress_.empty())
         StopDownloadProgress();
       LoadIcon(download);
       break;
     }
     case DownloadItem::IN_PROGRESS: {
       // If all IN_PROGRESS downloads are paused, don't waste CPU issuing any
       // further progress updates until at least one download is active again.
@@ skipping 39 matching lines @@
     }
   }
 }
 
 // A download has started or been deleted. Query our DownloadManager for the
 // current set of downloads, which will call us back in SetDownloads once it
 // has retrieved them.
 void DownloadTabView::ModelChanged() {
   downloads_.clear();
   ClearDownloadInProgress();
+  ClearDangerousDownloads();
   DetachAllFloatingViews();
 
   // Issue the query.
   model_->GetDownloads(this, search_text_);
 }
 
 void DownloadTabView::SetDownloads(std::vector<DownloadItem*>& downloads) {
   // Stop progress timers.
   StopDownloadProgress();
 
   // Clear out old state and remove self as observer for each download.
   downloads_.clear();
   ClearDownloadInProgress();
+  ClearDangerousDownloads();
 
   // Swap new downloads in.
   downloads_.swap(downloads);
   sort(downloads_.begin(), downloads_.end(), DownloadItemSorter());
 
   // Scan for any in progress downloads and add ourself to them as an observer.
   for (OrderedDownloads::iterator it = downloads_.begin();
        it != downloads_.end(); ++it) {
     DownloadItem* download = *it;
     if (download->state() == DownloadItem::IN_PROGRESS) {
       download->AddObserver(this);
       in_progress_.insert(download);
+    } else if (download->safety_state() == DownloadItem::DANGEROUS) {
+      // We need to be notified when the user validates the dangerous download.
+      download->AddObserver(this);
+      dangerous_downloads_.insert(download);
     }
   }
 
   // Start any progress timers if required.
   if (!in_progress_.empty())
     StartDownloadProgress();
 
   // Update the UI.
   selected_index_ = -1;
   GetParent()->GetParent()->Layout();
@@ skipping 27 matching lines @@
   icon_consumer_.SetClientData(im, h, download);
 }
 
 void DownloadTabView::ClearDownloadInProgress() {
   for (base::hash_set<DownloadItem*>::iterator it = in_progress_.begin();
        it != in_progress_.end(); ++it)
     (*it)->RemoveObserver(this);
   in_progress_.clear();
 }
 
+void DownloadTabView::ClearDangerousDownloads() {
+  base::hash_set<DownloadItem*>::const_iterator it;
+  for (it = dangerous_downloads_.begin();
+       it != dangerous_downloads_.end(); ++it)
+    (*it)->RemoveObserver(this);
+  dangerous_downloads_.clear();
+}
+
 // Check to see if the download is the latest download on a given day.
 // We use this to determine when to draw the date next to a particular
 // download view: if the DownloadItem is the latest download on a given
 // day, the date gets drawn.
 bool DownloadTabView::ShouldDrawDateForDownload(DownloadItem* download) {
   DCHECK(download);
   OrderedDownloads::iterator it = find(downloads_.begin(),
                                        downloads_.end(),
                                        download);
   DCHECK(it != downloads_.end());
@@ skipping 207 matching lines @@
       DCHECK(profile()->HasCreatedDownloadManager());
       contents_->SetIsLoading(
           profile()->GetDownloadManager()->in_progress_count() > 0,
           NULL);
       break;
     default:
       break;
   }
 }