Linux: Use the same safe downloads logic as Windows.

chrome/browser/download/download_util.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.
 //
 // Download utility implementation
 
 #include "chrome/browser/download/download_util.h"
 
-#if defined(OS_WIN)
-#include <shobjidl.h>
-#endif
+#define _USE_MATH_DEFINES  // For VC++ to get M_PI
+#include <cmath>
 #include <string>
 
 #include "base/file_util.h"
 #include "base/i18n/rtl.h"
 #include "base/i18n/time_formatting.h"
 #include "base/lazy_instance.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/sys_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/utf_string_conversions.h"
 #include "base/value_conversions.h"
 #include "base/values.h"
-#include "base/win/windows_version.h"
 #include "chrome/browser/download/download_extensions.h"
 #include "chrome/browser/download/download_item_model.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/time_format.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/download_item.h"
 #include "content/public/browser/download_manager.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/common/url_constants.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "grit/theme_resources.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_util.h"
 #include "skia/ext/image_operations.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "third_party/skia/include/core/SkShader.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/text/bytes_formatting.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/rect.h"
 
+#if defined(OS_WIN)
+#include <shobjidl.h>
+
+#include "base/win/windows_version.h"
+#endif
+
 #if defined(TOOLKIT_VIEWS)
 #include "ui/base/dragdrop/drag_utils.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/widget/widget.h"
 #endif
 
 #if defined(TOOLKIT_GTK)
 #include "chrome/browser/ui/gtk/custom_drag.h"
 #include "chrome/browser/ui/gtk/unity_service.h"
 #endif  // defined(TOOLKIT_GTK)
 
 #if defined(OS_WIN) && !defined(USE_AURA)
 #include "base/win/scoped_comptr.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #include "ui/base/dragdrop/drag_source.h"
 #include "ui/base/dragdrop/os_exchange_data_provider_win.h"
 #endif
 
-// TODO(phajdan.jr): Find some standard location for this, maintaining
-// the same value on all platforms.
-static const double PI = 3.141592653589793;
-
-using content::DownloadItem;
-
 namespace {
 
 // Returns a string constant to be used as the |danger_type| value in
 // CreateDownloadItemValue().  We only return strings for DANGEROUS_FILE,
 // DANGEROUS_URL, DANGEROUS_CONTENT, and UNCOMMON_CONTENT because the
 // |danger_type| value is only defined if the value of |state| is |DANGEROUS|.
 const char* GetDangerTypeString(content::DownloadDangerType danger_type) {
   switch (danger_type) {
     case content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE:
       return "DANGEROUS_FILE";
     case content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL:
       return "DANGEROUS_URL";
     case content::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT:
       return "DANGEROUS_CONTENT";
     case content::DOWNLOAD_DANGER_TYPE_UNCOMMON_CONTENT:
       return "UNCOMMON_CONTENT";
     default:
       // We shouldn't be returning a danger type string if it is
       // NOT_DANGEROUS or MAYBE_DANGEROUS_CONTENT.
       NOTREACHED();
       return "";
   }
 }
 
+// Get the opacity based on |animation_progress|, with values in [0.0, 1.0].
+// Range of return value is [0, 255].
+int GetOpacity(double animation_progress) {
+  DCHECK(animation_progress >= 0 && animation_progress <= 1);
+
+  // How many times to cycle the complete animation. This should be an odd
+  // number so that the animation ends faded out.
+  static const int kCompleteAnimationCycles = 5;
+  double temp = animation_progress * kCompleteAnimationCycles * M_PI + M_PI_2;
+  temp = sin(temp) / 2 + 0.5;
+  return static_cast<int>(255.0 * temp);
+}
+
 }  // namespace
 
 namespace download_util {
 
-// How many times to cycle the complete animation. This should be an odd number
-// so that the animation ends faded out.
-static const int kCompleteAnimationCycles = 5;
+using content::DownloadItem;
 
 // Download temporary file creation --------------------------------------------
 
 class DefaultDownloadDirectory {
  public:
   const FilePath& path() const { return path_; }
  private:
   DefaultDownloadDirectory() {
     if (!PathService::Get(chrome::DIR_DEFAULT_DOWNLOADS, &path_)) {
       NOTREACHED();
     }
     if (DownloadPathIsDangerous(path_)) {
+      // This is only useful on platforms that support
+      // DIR_DEFAULT_DOWNLOADS_SAFE.
       if (!PathService::Get(chrome::DIR_DEFAULT_DOWNLOADS_SAFE, &path_)) {
         NOTREACHED();
       }
     }
   }
   friend struct base::DefaultLazyInstanceTraits<DefaultDownloadDirectory>;
   FilePath path_;
 };
 
 static base::LazyInstance<DefaultDownloadDirectory>
     g_default_download_directory = LAZY_INSTANCE_INITIALIZER;
 
 const FilePath& GetDefaultDownloadDirectory() {
   return g_default_download_directory.Get().path();
 }
 
+// Consider downloads 'dangerous' if they go to the home directory on Linux and
+// to the desktop on any platform.
 bool DownloadPathIsDangerous(const FilePath& download_path) {
+#if defined(OS_LINUX)
+  FilePath home_dir = file_util::GetHomeDir();
+  if (download_path == home_dir) {
+    return true;
+  }
+#endif
+
   FilePath desktop_dir;
   if (!PathService::Get(chrome::DIR_USER_DESKTOP, &desktop_dir)) {
     NOTREACHED();
     return false;
   }
   return (download_path == desktop_dir);
 }
 
 void GenerateFileNameFromRequest(const DownloadItem& download_item,
                                  FilePath* generated_name) {
@@ skipping 136 matching lines @@
 
   gfx::Rect complete_bounds(origin_x, origin_y,
                             complete->width(), complete->height());
 #if defined(TOOLKIT_VIEWS)
   // Mirror the positions if necessary.
   complete_bounds.set_x(containing_view->GetMirroredXForRect(complete_bounds));
 #endif
 
   // Start at full opacity, then loop back and forth five times before ending
   // at zero opacity.
-  double opacity = sin(animation_progress * PI * kCompleteAnimationCycles +
-                   PI/2) / 2 + 0.5;
-
-  canvas->SaveLayerAlpha(static_cast<int>(255.0 * opacity), complete_bounds);
+  canvas->SaveLayerAlpha(GetOpacity(animation_progress), complete_bounds);
   canvas->sk_canvas()->drawARGB(0, 255, 255, 255, SkXfermode::kClear_Mode);
   canvas->DrawBitmapInt(*complete, complete_bounds.x(), complete_bounds.y());
   canvas->Restore();
 }
 
 void PaintDownloadInterrupted(gfx::Canvas* canvas,
 #if defined(TOOLKIT_VIEWS)
                               views::View* containing_view,
 #endif
                               int origin_x,
@@ skipping 11 matching lines @@
 
   gfx::Rect complete_bounds(origin_x, origin_y,
                             complete->width(), complete->height());
 #if defined(TOOLKIT_VIEWS)
   // Mirror the positions if necessary.
   complete_bounds.set_x(containing_view->GetMirroredXForRect(complete_bounds));
 #endif
 
   // Start at zero opacity, then loop back and forth five times before ending
   // at full opacity.
-  double opacity = sin(
-      (1.0 - animation_progress) * PI * kCompleteAnimationCycles + PI/2) / 2 +
-          0.5;
-
-  canvas->SaveLayerAlpha(static_cast<int>(255.0 * opacity), complete_bounds);
+  canvas->SaveLayerAlpha(GetOpacity(1.0 - animation_progress), complete_bounds);
   canvas->sk_canvas()->drawARGB(0, 255, 255, 255, SkXfermode::kClear_Mode);
   canvas->DrawBitmapInt(*complete, complete_bounds.x(), complete_bounds.y());
   canvas->Restore();
 }
 
 // Load a language dependent height so that the dangerous download confirmation
 // message doesn't overlap with the download link label.
 int GetBigProgressIconSize() {
   static int big_progress_icon_size = 0;
   if (big_progress_icon_size == 0) {
@@ skipping 42 matching lines @@
   }
 
 #if !defined(TOOLKIT_GTK)
 #if defined(USE_AURA)
   views::Widget* widget = views::Widget::GetWidgetForNativeView(view);
   gfx::Point location = gfx::Screen::GetCursorScreenPoint();
   // We do not care about notifying the DragItemView on completion of drag. So
   // we pass NULL to RunShellDrag for the source view.
   widget->RunShellDrag(NULL, data, location,
       ui::DragDropTypes::DRAG_COPY | ui::DragDropTypes::DRAG_LINK);
-#else // We are on WIN without AURA
+#else  // We are on WIN without AURA
   // We cannot use Widget::RunShellDrag on WIN since the |view| is backed by a
   // TabContentsViewWin, not a NativeWidgetWin.
   scoped_refptr<ui::DragSource> drag_source(new ui::DragSource);
   // Run the drag and drop loop
   DWORD effects;
   DoDragDrop(ui::OSExchangeDataProviderWin::GetIDataObject(data),
              drag_source.get(), DROPEFFECT_COPY | DROPEFFECT_LINK, &effects);
 #endif
 
 #else
@@ skipping 231 matching lines @@
   UMA_HISTOGRAM_ENUMERATION(
       "Download.CountsChrome", type, CHROME_DOWNLOAD_COUNT_TYPES_LAST_ENTRY);
 }
 
 void RecordDownloadSource(ChromeDownloadSource source) {
   UMA_HISTOGRAM_ENUMERATION(
       "Download.SourcesChrome", source, CHROME_DOWNLOAD_SOURCE_LAST_ENTRY);
 }
 
 }  // namespace download_util