Refactor dangerous download warning text generation into DownloadItemModel.

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 175 matching lines @@
   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);
 
   new_item_animation_.reset(new ui::SlideAnimation(this));
   new_item_animation_->SetSlideDuration(kNewItemAnimationDurationMs);
   gtk_widget_show_all(hbox_.get());
 
-  if (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(
-        l10n_util::GetStringUTF8(
-            ChromeDownloadManagerDelegate::IsExtensionDownload(
-                download_model->download()) ?
-                    IDS_CONTINUE_EXTENSION_DOWNLOAD :
-                    IDS_CONFIRM_DOWNLOAD).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 (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);
@@ skipping 17 matching lines @@
   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());
 
-  if (dangerous_prompt_ != NULL &&
-      download->GetSafetyState() == DownloadItem::DANGEROUS_BUT_VALIDATED) {
+  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();
@@ skipping 52 matching lines @@
 
   status_text_ = UTF16ToUTF8(download_model_->GetStatusText());
   UpdateStatusLabel(status_text_);
 }
 
 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 (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 29 matching lines @@
     UpdateNameLabel();
     UpdateStatusLabel(status_text_);
     UpdateDangerWarning();
   }
 }
 
 DownloadItem* DownloadItemGtk::get_download() {
   return download_model_->download();
 }
 
-bool DownloadItemGtk::IsDangerous() {
-  return get_download()->GetSafetyState() == 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_.get());
 }
 
 void DownloadItemGtk::StartDownloadProgress() {
@@ skipping 117 matching lines @@
       theme_service_->UsingNativeTheme() ? NULL : &text_color);
   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;
-
-    // The dangerous download label text is different for different cases.
-    if (get_download()->GetDangerType() ==
-            content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL) {
-      // TODO(noelutz): handle malicious content warning.
-      // Safebrowsing shows the download URL leads to malicious file.
-      dangerous_warning =
-          l10n_util::GetStringUTF16(IDS_PROMPT_MALICIOUS_DOWNLOAD_URL);
-    } else {
-      // It's a dangerous file type (e.g.: an executable).
-      DCHECK(get_download()->GetDangerType() ==
-             content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE);
-      if (ChromeDownloadManagerDelegate::IsExtensionDownload(get_download())) {
-        dangerous_warning =
-            l10n_util::GetStringUTF16(IDS_PROMPT_DANGEROUS_DOWNLOAD_EXTENSION);
-      } else {
-        string16 elided_filename = ui::ElideFilename(
-            get_download()->GetTargetName(), gfx::Font(), kTextWidth);
-        dangerous_warning =
-            l10n_util::GetStringFUTF16(IDS_PROMPT_DANGEROUS_DOWNLOAD,
-                                       elided_filename);
-      }
-    }
-
+    string16 dangerous_warning =
+        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 = get_download()->GetDangerType() ==
-        content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL ?
-            GTK_STOCK_DIALOG_ERROR : GTK_STOCK_DIALOG_WARNING;
+    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 = get_download()->GetDangerType() ==
-        content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL ?
-            IDR_SAFEBROWSING_WARNING : IDR_WARNING;
+    int pixbuf_id = download_model_->IsMalicious() ?
+        IDR_SAFEBROWSING_WARNING : IDR_WARNING;
     GdkPixbuf* download_pixbuf = rb.GetNativeImageNamed(pixbuf_id);
     gtk_image_set_from_pixbuf(GTK_IMAGE(dangerous_image_), download_pixbuf);
   }
 }
 
 // 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 (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 171 matching lines @@
   get_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);
 }