Display error-specific messages when a download is interrupted.

Depends on CL 9837061.

BUG=None
TEST=None


Review URL: http://codereview.chromium.org/8467001

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@130257 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 195 insertions, 3 deletions

diff --git a/chrome/browser/download/download_item_model.cc b/chrome/browser/download/download_item_model.cc
index 187d6a3..87785ea 100644
--- a/chrome/browser/download/download_item_model.cc
+++ b/chrome/browser/download/download_item_model.cc
@@ -12,6 +12,7 @@
 #include "chrome/browser/download/chrome_download_manager_delegate.h"
 #include "chrome/common/time_format.h"
 #include "content/public/browser/download_danger_type.h"
+#include "content/public/browser/download_interrupt_reasons.h"
 #include "content/public/browser/download_item.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
@@ -70,7 +71,9 @@ string16 DownloadItemModel::GetStatusText() {
                       TimeFormat::TimeRemaining(remaining);
   }
 
+  string16 size_text;
   string16 status_text;
+  content::DownloadInterruptReason reason;
   switch (download_->GetState()) {
     case DownloadItem::IN_PROGRESS:
 #if defined(OS_CHROMEOS)
@@ -127,9 +130,18 @@ string16 DownloadItemModel::GetStatusText() {
     case DownloadItem::REMOVING:
       break;
     case DownloadItem::INTERRUPTED:
-      status_text = l10n_util::GetStringFUTF16(IDS_DOWNLOAD_STATUS_INTERRUPTED,
+      reason = download_->GetLastReason();
+      status_text = InterruptReasonStatusMessage(reason);
+      if (total <= 0) {
+        size_text = ui::FormatBytes(size);
+      } else {
+        size_text = l10n_util::GetStringFUTF16(IDS_DOWNLOAD_RECEIVED_SIZE,
                                                simple_size,
                                                simple_total);
+      }
+      size_text = size_text + ASCIIToUTF16(" ");
+      if (reason != content::DOWNLOAD_INTERRUPT_REASON_USER_CANCELED)
+        status_text = size_text + status_text;
       break;
     default:
       NOTREACHED();
@@ -226,6 +238,62 @@ bool DownloadItemModel::IsDangerous() {
 }
 
 // static
+string16 BaseDownloadItemModel::InterruptReasonStatusMessage(int reason) {
+  int string_id = 0;
+
+  switch (reason) {
+    case content::DOWNLOAD_INTERRUPT_REASON_FILE_ACCESS_DENIED:
+      string_id = IDS_DOWNLOAD_INTERRUPTED_STATUS_ACCESS_DENIED;
+      break;
+    case content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE:
+      string_id = IDS_DOWNLOAD_INTERRUPTED_STATUS_DISK_FULL;
+      break;
+    case content::DOWNLOAD_INTERRUPT_REASON_FILE_NAME_TOO_LONG:
+      string_id = IDS_DOWNLOAD_INTERRUPTED_STATUS_PATH_TOO_LONG;
+      break;
+    case content::DOWNLOAD_INTERRUPT_REASON_FILE_TOO_LARGE:
+      string_id = IDS_DOWNLOAD_INTERRUPTED_STATUS_FILE_TOO_LARGE;
+      break;
+    case content::DOWNLOAD_INTERRUPT_REASON_FILE_VIRUS_INFECTED:
+      string_id = IDS_DOWNLOAD_INTERRUPTED_STATUS_VIRUS;
+      break;
+    case content::DOWNLOAD_INTERRUPT_REASON_FILE_TRANSIENT_ERROR:
+      string_id = IDS_DOWNLOAD_INTERRUPTED_STATUS_TEMPORARY_PROBLEM;
+      break;
+    case content::DOWNLOAD_INTERRUPT_REASON_NETWORK_TIMEOUT:
+      string_id = IDS_DOWNLOAD_INTERRUPTED_STATUS_NETWORK_TIMEOUT;
+      break;
+    case content::DOWNLOAD_INTERRUPT_REASON_NETWORK_DISCONNECTED:
+      string_id = IDS_DOWNLOAD_INTERRUPTED_STATUS_NETWORK_DISCONNECTED;
+      break;
+    case content::DOWNLOAD_INTERRUPT_REASON_NETWORK_SERVER_DOWN:
+      string_id = IDS_DOWNLOAD_INTERRUPTED_STATUS_SERVER_DOWN;
+      break;
+    case content::DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED:
+      string_id = IDS_DOWNLOAD_INTERRUPTED_STATUS_NETWORK_ERROR;
+      break;
+    case content::DOWNLOAD_INTERRUPT_REASON_SERVER_BAD_CONTENT:
+      string_id = IDS_DOWNLOAD_INTERRUPTED_STATUS_NO_FILE;
+      break;
+    case content::DOWNLOAD_INTERRUPT_REASON_SERVER_FAILED:
+      string_id = IDS_DOWNLOAD_INTERRUPTED_STATUS_SERVER_PROBLEM;
+      break;
+    case content::DOWNLOAD_INTERRUPT_REASON_USER_SHUTDOWN:
+    case content::DOWNLOAD_INTERRUPT_REASON_CRASH:
+      string_id = IDS_DOWNLOAD_INTERRUPTED_STATUS_SHUTDOWN;
+      break;
+    case content::DOWNLOAD_INTERRUPT_REASON_USER_CANCELED:
+      string_id = IDS_DOWNLOAD_STATUS_CANCELED;
+      break;
+    default:
+      string_id = IDS_DOWNLOAD_INTERRUPTED_STATUS;
+      break;
+  }
+
+  return l10n_util::GetStringUTF16(string_id);
+}
+
+// static
 string16 BaseDownloadItemModel::InterruptReasonMessage(int reason) {
   int string_id = 0;
   string16 status_text;
diff --git a/chrome/browser/download/download_item_model.h b/chrome/browser/download/download_item_model.h
index 970e664..bddf911 100644
--- a/chrome/browser/download/download_item_model.h
+++ b/chrome/browser/download/download_item_model.h
@@ -54,11 +54,14 @@ class BaseDownloadItemModel {
   // Is this considered a dangerous download?
   virtual bool IsDangerous() = 0;
 
+  content::DownloadItem* download() { return download_; }
+
+  // Get the status message of the given interrupt |reason|.
+  static string16 InterruptReasonStatusMessage(int reason);
+
   // Get the description of the given interrupt |reason|.
   static string16 InterruptReasonMessage(int reason);
 
-  content::DownloadItem* download() { return download_; }
-
  protected:
   content::DownloadItem* download_;
 };
diff --git a/chrome/browser/download/download_item_model_unittest.cc b/chrome/browser/download/download_item_model_unittest.cc
new file mode 100644
index 0000000..9f32de2
--- /dev/null
+++ b/chrome/browser/download/download_item_model_unittest.cc
@@ -0,0 +1,118 @@
+// 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/download/download_item_model.h"
+
+#include "base/i18n/rtl.h"
+#include "base/logging.h"
+#include "base/message_loop.h"
+#include "base/string16.h"
+#include "base/utf_string_conversions.h"
+#include "content/test/mock_download_item.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "grit/generated_resources.h"
+#include "ui/base/l10n/l10n_util.h"
+#include "ui/base/text/bytes_formatting.h"
+
+using ::testing::AtLeast;
+using ::testing::Mock;
+using ::testing::NiceMock;
+using ::testing::Return;
+using ::testing::ReturnRef;
+using ::testing::ReturnRefOfCopy;
+using ::testing::SetArgPointee;
+using ::testing::StrictMock;
+using ::testing::_;
+
+content::DownloadId::Domain kValidIdDomain = "valid DownloadId::Domain";
+
+class DownloadItemModelTest : public testing::Test {
+ public:
+  DownloadItemModelTest() {}
+
+  virtual ~DownloadItemModelTest() {
+  }
+
+ protected:
+  void SetupDownloadItemDefaults() {
+    ON_CALL(item_, GetReceivedBytes()).WillByDefault(Return(1024));
+    ON_CALL(item_, GetTotalBytes()).WillByDefault(Return(2048));
+    ON_CALL(item_, IsInProgress()).WillByDefault(Return(false));
+    ON_CALL(item_, TimeRemaining(_)).WillByDefault(Return(false));
+    ON_CALL(item_, GetState()).
+        WillByDefault(Return(content::DownloadItem::INTERRUPTED));
+    ON_CALL(item_, PromptUserForSaveLocation()).
+        WillByDefault(Return(false));
+    ON_CALL(item_, GetMimeType()).WillByDefault(Return("text/html"));
+    ON_CALL(item_, AllDataSaved()).WillByDefault(Return(false));
+    ON_CALL(item_, GetOpenWhenComplete()).WillByDefault(Return(false));
+    ON_CALL(item_, GetFileExternallyRemoved()).WillByDefault(Return(false));
+  }
+
+  void SetupDownloadItem(const GURL& url,
+                         content::DownloadInterruptReason reason) {
+    model_.reset(new DownloadItemModel(&item_));
+    EXPECT_CALL(item_, GetURL()).WillRepeatedly(ReturnRefOfCopy(url));
+    EXPECT_CALL(item_, GetLastReason()).WillOnce(Return(reason));
+  }
+
+  void TestDownloadItemModelStatusText(
+      const GURL& url, content::DownloadInterruptReason reason) {
+    SetupDownloadItem(url, reason);
+
+    int64 size = item_.GetReceivedBytes();
+    int64 total = item_.GetTotalBytes();
+    bool know_size = (total > 0);
+
+    ui::DataUnits amount_units = ui::GetByteDisplayUnits(total);
+    string16 simple_size = ui::FormatBytesWithUnits(size, amount_units, false);
+    string16 simple_total = base::i18n::GetDisplayStringInLTRDirectionality(
+        ui::FormatBytesWithUnits(total, amount_units, true));
+
+    string16 status_text;
+    string16 size_text;
+
+    status_text = DownloadItemModel::InterruptReasonStatusMessage(reason);
+
+    if (know_size) {
+      size_text = l10n_util::GetStringFUTF16(IDS_DOWNLOAD_RECEIVED_SIZE,
+                                             simple_size,
+                                             simple_total);
+    } else {
+      size_text = ui::FormatBytes(size);
+    }
+    size_text = size_text + ASCIIToUTF16(" ");
+    if (reason != content::DOWNLOAD_INTERRUPT_REASON_USER_CANCELED)
+      status_text = size_text + status_text;
+
+    DVLOG(2) << " " << __FUNCTION__ << "()" << " '" << status_text << "'";
+
+    string16 text = model_->GetStatusText();
+
+    EXPECT_EQ(status_text, text);
+  }
+
+  void TestDownloadItemModelStatusTextAllReasons(const GURL& url) {
+    SetupDownloadItemDefaults();
+
+#define INTERRUPT_REASON(name, value)  \
+    TestDownloadItemModelStatusText(url, \
+                                    content::DOWNLOAD_INTERRUPT_REASON_##name);
+
+  #include "content/public/browser/download_interrupt_reason_values.h"
+
+#undef INTERRUPT_REASON
+  }
+
+ private:
+  scoped_ptr<DownloadItemModel> model_;
+
+  NiceMock<content::MockDownloadItem> item_;
+};
+
+// Test download error messages.
+TEST_F(DownloadItemModelTest, Interrupts) {
+  TestDownloadItemModelStatusTextAllReasons(GURL("http://foo.bar/"));
+}
diff --git a/chrome/browser/download/download_util.cc b/chrome/browser/download/download_util.cc
index d1eb22a..5bfa4e2 100644
--- a/chrome/browser/download/download_util.cc
+++ b/chrome/browser/download/download_util.cc
@@ -496,6 +496,9 @@ DictionaryValue* CreateDownloadItemValue(DownloadItem* download, int id) {
         static_cast<int>(download->PercentComplete()));
     file_value->SetInteger("received",
         static_cast<int>(download->GetReceivedBytes()));
+    file_value->SetString("last_reason_text",
+        BaseDownloadItemModel::InterruptReasonMessage(
+            download->GetLastReason()));
   } else if (download->IsCancelled()) {
     file_value->SetString("state", "CANCELLED");
   } else if (download->IsComplete()) {