Implemented ExternalData interface on DownloadItem and used it for SafeBrowsing.

chrome/browser/download/download_item_unittest.cc

 // Copyright (c) 2011 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 "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/threading/thread.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/browser/download/download_create_info.h"
 #include "content/browser/download/download_id.h"
@@ skipping 73 matching lines @@
   virtual void SetUp() {
   }
 
   virtual void TearDown() {
     ui_thread_.DeprecatedGetThreadObject()->message_loop()->RunAllPending();
     STLDeleteElements(&allocated_downloads_);
     allocated_downloads_.clear();
   }
 
   // This class keeps ownership of the created download item; it will
-  // be torn down at the end of the test.
+  // be torn down at the end of the test unless DestroyDownloadItem is
+  // called.
   DownloadItem* CreateDownloadItem(DownloadItem::DownloadState state) {
     // Normally, the download system takes ownership of info, and is
     // responsible for deleting it.  In these unit tests, however, we
     // don't call the function that deletes it, so we do so ourselves.
     scoped_ptr<DownloadCreateInfo> info_;
 
     info_.reset(new DownloadCreateInfo());
     info_->download_id = id_factory_->GetNextId();
     info_->prompt_user_for_save_location = false;
     info_->url_chain.push_back(GURL());
     info_->state = state;
 
     MockRequestHandle* request_handle =
         new testing::NiceMock<MockRequestHandle>;
     DownloadItem* download =
         new DownloadItemImpl(&delegate_, *(info_.get()),
                              request_handle, false);
-    allocated_downloads_.push_back(download);
+    allocated_downloads_.insert(download);
     return download;
   }
 
+  // Destroy a previously created download item.
+  void DestroyDownloadItem(DownloadItem* item) {
+    allocated_downloads_.erase(item);
+    delete item;
+  }
+
  protected:
   DownloadStatusUpdater download_status_updater_;
 
  private:
   scoped_refptr<DownloadIdFactory> id_factory_;
   MessageLoopForUI loop_;
   // UI thread.
   content::TestBrowserThread ui_thread_;
   testing::NiceMock<MockDelegate> delegate_;
-  std::vector<DownloadItem*> allocated_downloads_;
+  std::set<DownloadItem*> allocated_downloads_;
 };
 
 namespace {
 
 const int kDownloadChunkSize = 1000;
 const int kDownloadSpeed = 1000;
 const int kDummyDBHandle = 10;
 const FilePath::CharType kDummyPath[] = FILE_PATH_LITERAL("/testpath");
 
 } // namespace
@@ skipping 131 matching lines @@
   DownloadItem* item = CreateDownloadItem(DownloadItem::IN_PROGRESS);
   MockObserver observer(item);
 
   item->TogglePause();
   ASSERT_TRUE(observer.CheckUpdated());
 
   item->TogglePause();
   ASSERT_TRUE(observer.CheckUpdated());
 }
 
+static char external_data_test_string[] = "External data test";
+static int destructor_called = 0;
+
+class TestExternalData : public DownloadItem::ExternalData {
+ public:
+  int value;
+  virtual ~TestExternalData() {
+    destructor_called++;
+  }
+};
+
+TEST_F(DownloadItemTest, ExternalData) {
+  DownloadItem* item = CreateDownloadItem(DownloadItem::IN_PROGRESS);
+
+  // Shouldn't be anything there before set.
+  EXPECT_EQ(NULL, item->GetExternalData(&external_data_test_string));
+
+  TestExternalData* test1(new TestExternalData());
+  test1->value = 2;
+
+  // Should be able to get back what you set.
+  item->SetExternalData(&external_data_test_string, test1);
+  TestExternalData* test_result =
+      static_cast<TestExternalData*>(
+          item->GetExternalData(&external_data_test_string));
+  EXPECT_EQ(test1, test_result);
+
+  // Destructor should be called if value overwritten.  New value
+  // should then be retrievable.
+  TestExternalData* test2(new TestExternalData());
+  test2->value = 3;
+  EXPECT_EQ(0, destructor_called);
+  item->SetExternalData(&external_data_test_string, test2);
+  EXPECT_EQ(1, destructor_called);
+  EXPECT_EQ(static_cast<DownloadItem::ExternalData*>(test2),
+            item->GetExternalData(&external_data_test_string));
+
+  // Overwriting with the same value shouldn't do anything.
+  EXPECT_EQ(1, destructor_called);
+  item->SetExternalData(&external_data_test_string, test2);
+  EXPECT_EQ(1, destructor_called);
+  EXPECT_EQ(static_cast<DownloadItem::ExternalData*>(test2),
+            item->GetExternalData(&external_data_test_string));
+
+  // Overwriting with NULL should result in destruction.
+  item->SetExternalData(&external_data_test_string, NULL);
+  EXPECT_EQ(2, destructor_called);
+
+  // Destroying the download item should destroy the external data.
+
+  TestExternalData* test3(new TestExternalData());
+  item->SetExternalData(&external_data_test_string, test3);
+  EXPECT_EQ(static_cast<DownloadItem::ExternalData*>(test3),
+            item->GetExternalData(&external_data_test_string));
+  DestroyDownloadItem(item);
+  EXPECT_EQ(3, destructor_called);
+}
+
 TEST(MockDownloadItem, Compiles) {
   MockDownloadItem mock_item;
 }