Use DownloadItemModel for storing chrome/ specific UI data for DownloadItems.

chrome/browser/download/download_item_model_unittest.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/download/download_item_model.h"
 
 #include <vector>
 
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
@@ skipping 23 matching lines @@
 // that all the interrupt reason codes are accounted for. The reason codes are
 // unfortunately sparse, making this necessary.
 char kInterruptReasonCounter[] = {
   0,                                // content::DOWNLOAD_INTERRUPT_REASON_NONE
 #define INTERRUPT_REASON(name,value) 0,
 #include "content/public/browser/download_interrupt_reason_values.h"
 #undef INTERRUPT_REASON
 };
 const size_t kInterruptReasonCount = ARRAYSIZE_UNSAFE(kInterruptReasonCounter);
 
-// DownloadItemModel with mocks several methods.
-class TestDownloadItemModel : public DownloadItemModel {
- public:
-  explicit TestDownloadItemModel(content::DownloadItem* download)
-      : DownloadItemModel(download) {
-  }
+// Default target path for a mock download item in DownloadItemModelTest.
+const FilePath::CharType kDefaultTargetFilePath[] =
+    FILE_PATH_LITERAL("/foo/bar/foo.bar");
 
-  MOCK_CONST_METHOD0(GetTotalBytes, int64());
-  MOCK_CONST_METHOD0(GetCompletedBytes, int64());
-};
+const FilePath::CharType kDefaultDisplayFileName[] =
+    FILE_PATH_LITERAL("foo.bar");
+
+// Default URL for a mock download item in DownloadItemModelTest.
+const char kDefaultURL[] = "http://example.com/foo.bar";
 
 class DownloadItemModelTest : public testing::Test {
  public:
-  DownloadItemModelTest() {}
+  DownloadItemModelTest()
+      : model_(&item_) {}
 
   virtual ~DownloadItemModelTest() {
   }
 
  protected:
   // Sets up defaults for the download item and sets |model_| to a new
   // DownloadItemModel that uses the mock download item.
   void SetupDownloadItemDefaults() {
     ON_CALL(item_, GetReceivedBytes()).WillByDefault(Return(1));
     ON_CALL(item_, GetTotalBytes()).WillByDefault(Return(2));
     ON_CALL(item_, IsInProgress()).WillByDefault(Return(true));
     ON_CALL(item_, TimeRemaining(_)).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));
     ON_CALL(item_, GetState())
         .WillByDefault(Return(content::DownloadItem::IN_PROGRESS));
     ON_CALL(item_, GetURL())
-        .WillByDefault(ReturnRefOfCopy(GURL("http://example.com/foo.bar")));
+        .WillByDefault(ReturnRefOfCopy(GURL(kDefaultURL)));
     ON_CALL(item_, GetFileNameToReportUser())
-        .WillByDefault(Return(FilePath(FILE_PATH_LITERAL("foo.bar"))));
+        .WillByDefault(Return(FilePath(kDefaultDisplayFileName)));
+    ON_CALL(item_, GetTargetFilePath())
+        .WillByDefault(ReturnRefOfCopy(FilePath(kDefaultTargetFilePath)));
     ON_CALL(item_, GetTargetDisposition())
         .WillByDefault(
             Return(content::DownloadItem::TARGET_DISPOSITION_OVERWRITE));
     ON_CALL(item_, IsPaused()).WillByDefault(Return(false));
-
-    // Setup the model:
-    model_.reset(new NiceMock<TestDownloadItemModel>(&item_));
-    ON_CALL(*model_.get(), GetTotalBytes())
-        .WillByDefault(Return(2));
-    ON_CALL(*model_.get(), GetCompletedBytes())
-        .WillByDefault(Return(1));
   }
 
   void SetupInterruptedDownloadItem(content::DownloadInterruptReason reason) {
     EXPECT_CALL(item_, GetLastReason()).WillRepeatedly(Return(reason));
     EXPECT_CALL(item_, GetState())
         .WillRepeatedly(Return(
             (reason == content::DOWNLOAD_INTERRUPT_REASON_NONE) ?
                 content::DownloadItem::IN_PROGRESS :
                 content::DownloadItem::INTERRUPTED));
     EXPECT_CALL(item_, IsInProgress())
         .WillRepeatedly(Return(
             reason == content::DOWNLOAD_INTERRUPT_REASON_NONE));
   }
 
   content::MockDownloadItem& item() {
     return item_;
   }
 
-  TestDownloadItemModel& model() {
-    return *model_;
+  DownloadItemModel& model() {
+    return model_;
   }
 
  private:
-  scoped_ptr<TestDownloadItemModel> model_;
-
   NiceMock<content::MockDownloadItem> item_;
+  DownloadItemModel model_;
 };
 
 }  // namespace
 
 TEST_F(DownloadItemModelTest, InterruptedStatus) {
   // Test that we have the correct interrupt status message for downloads that
   // are in the INTERRUPTED state.
   const struct TestCase {
     // The reason.
     content::DownloadInterruptReason reason;
@@ skipping 194 matching lines @@
     { 0, 2, true,  true,  true,  "0/2 B, Paused" },
     { 1, 2, true,  true,  true,  "1/2 B, Paused" },
   };
 
   SetupDownloadItemDefaults();
 
   for (unsigned i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); i++) {
     TestCase& test_case = kTestCases[i];
     Mock::VerifyAndClearExpectations(&item());
     Mock::VerifyAndClearExpectations(&model());
-    EXPECT_CALL(model(), GetCompletedBytes())
+    EXPECT_CALL(item(), GetReceivedBytes())
         .WillRepeatedly(Return(test_case.received_bytes));
-    EXPECT_CALL(model(), GetTotalBytes())
+    EXPECT_CALL(item(), GetTotalBytes())
         .WillRepeatedly(Return(test_case.total_bytes));
     EXPECT_CALL(item(), TimeRemaining(_))
         .WillRepeatedly(testing::DoAll(
             testing::SetArgPointee<0>(base::TimeDelta::FromSeconds(10)),
             Return(test_case.time_remaining_known)));
     EXPECT_CALL(item(), GetOpenWhenComplete())
         .WillRepeatedly(Return(test_case.open_when_complete));
     EXPECT_CALL(item(), IsPaused())
         .WillRepeatedly(Return(test_case.is_paused));
 
     EXPECT_STREQ(test_case.expected_status,
                  UTF16ToUTF8(model().GetStatusText()).c_str());
   }
 }
+
+TEST_F(DownloadItemModelTest, ShouldShowInShelf) {
+  SetupDownloadItemDefaults();
+
+  // By default the download item should be displayable on the shelf.
+  EXPECT_TRUE(model().ShouldShowInShelf());
+
+  // Once explicitly set, ShouldShowInShelf() should return the explicit value.
+  model().SetShouldShowInShelf(false);
+  EXPECT_FALSE(model().ShouldShowInShelf());
+
+  model().SetShouldShowInShelf(true);
+  EXPECT_TRUE(model().ShouldShowInShelf());
+}