Created a DownloadManager interface, for use in unit tests..

chrome/browser/download/download_manager_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 <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/i18n/number_formatting.h"
@@ skipping 37 matching lines @@
 class DownloadManagerTest : public testing::Test {
  public:
   static const char* kTestData;
   static const size_t kTestDataLen;
 
   DownloadManagerTest()
       : profile_(new TestingProfile()),
         download_manager_delegate_(new ChromeDownloadManagerDelegate(
             profile_.get())),
         id_factory_(new DownloadIdFactory(kValidIdDomain)),
-        download_manager_(new MockDownloadManager(
+        download_manager_(new DownloadManager(
             download_manager_delegate_,
             id_factory_,
             &download_status_updater_)),
         ui_thread_(BrowserThread::UI, &message_loop_),
         file_thread_(BrowserThread::FILE, &message_loop_),
         download_buffer_(new content::DownloadBuffer) {
     download_manager_->Init(profile_.get());
     download_manager_delegate_->SetDownloadManager(download_manager_);
   }
 
@@ skipping 42 matching lines @@
     message_loop_.RunAllPending();
   }
 
   void OnDownloadInterrupted(int32 download_id, int64 size,
                              InterruptReason reason) {
     download_manager_->OnDownloadInterrupted(download_id, size, reason);
   }
 
   // Get the download item with ID |id|.
   DownloadItem* GetActiveDownloadItem(int32 id) {
-    if (ContainsKey(download_manager_->active_downloads_, id))
-      return download_manager_->active_downloads_[id];
-    return NULL;
+    return download_manager_->GetActiveDownload(id);
   }
 
  protected:
   DownloadStatusUpdater download_status_updater_;
   scoped_ptr<TestingProfile> profile_;
   scoped_refptr<ChromeDownloadManagerDelegate> download_manager_delegate_;
   scoped_refptr<DownloadIdFactory> id_factory_;
-  scoped_refptr<DownloadManager> download_manager_;
+  scoped_refptr<DownloadManagerInterface> download_manager_;
   scoped_refptr<DownloadFileManager> file_manager_;
   MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
   scoped_refptr<content::DownloadBuffer> download_buffer_;
 
   DownloadFileManager* file_manager() {
     if (!file_manager_) {
       file_manager_ = new DownloadFileManager(NULL);
-      download_manager_->file_manager_ = file_manager_;
+      download_manager_->SetFileManager(file_manager_);
     }
     return file_manager_;
   }
 
   // Make sure download item |id| was set with correct safety state for
   // given |is_dangerous_file| and |is_dangerous_url|.
   bool VerifySafetyState(bool is_dangerous_file,
                          bool is_dangerous_url,
                          int id) {
     DownloadItem::SafetyState safety_state =
         download_manager_->GetDownloadItem(id)->safety_state();
     return (is_dangerous_file || is_dangerous_url) ?
         safety_state != DownloadItem::SAFE : safety_state == DownloadItem::SAFE;
   }
 
   DISALLOW_COPY_AND_ASSIGN(DownloadManagerTest);
 };
 
 const char* DownloadManagerTest::kTestData = "a;sdlfalsdfjalsdkfjad";
 const size_t DownloadManagerTest::kTestDataLen =
     strlen(DownloadManagerTest::kTestData);
 
 // A DownloadFile that we can inject errors into.  Uses MockFileStream.
 // Note:  This can't be in an anonymous namespace because it must be declared
 // as a friend of |DownloadFile| in order to access its private members.
 class DownloadFileWithMockStream : public DownloadFile {
  public:
   DownloadFileWithMockStream(DownloadCreateInfo* info,
-                             DownloadManager* manager,
+                             DownloadManagerInterface* manager,
                              net::testing::MockFileStream* stream);
 
   virtual ~DownloadFileWithMockStream() {}
 
   void SetForcedError(int error);
 
  protected:
   // This version creates a |MockFileStream| instead of a |FileStream|.
   virtual void CreateFileStream() OVERRIDE;
 };
 
 DownloadFileWithMockStream::DownloadFileWithMockStream(
     DownloadCreateInfo* info,
-    DownloadManager* manager,
+    DownloadManagerInterface* manager,
     net::testing::MockFileStream* stream)
     : DownloadFile(info, DownloadRequestHandle(), manager) {
   DCHECK(file_stream_ == NULL);
   file_stream_.reset(stream);
 }
 
 void DownloadFileWithMockStream::SetForcedError(int error)
 {
   // |file_stream_| can only be set in the constructor and in
   // CreateFileStream(), both of which insure that it is a |MockFileStream|.
@@ skipping 78 matching lines @@
   { FILE_PATH_LITERAL("foo.zip"), false, false, false, 2, },
   // Dangerous download, download finishes AFTER file name determined.
   // Needs to be renamed only once.
   { FILE_PATH_LITERAL("Unconfirmed xxx.crdownload"), true, false, false, 1, },
   { FILE_PATH_LITERAL("Unconfirmed xxx.crdownload"), false, true, false, 1, },
   { FILE_PATH_LITERAL("Unconfirmed xxx.crdownload"), true, true, false, 1, },
 };
 
 class MockDownloadFile : public DownloadFile {
  public:
-  MockDownloadFile(DownloadCreateInfo* info, DownloadManager* manager)
+  MockDownloadFile(DownloadCreateInfo* info, DownloadManagerInterface* manager)
       : DownloadFile(info, DownloadRequestHandle(), manager),
         renamed_count_(0) { }
   virtual ~MockDownloadFile() { Destructed(); }
   MOCK_METHOD1(Rename, net::Error(const FilePath&));
   MOCK_METHOD0(Destructed, void());
 
   net::Error TestMultipleRename(
       int expected_count, const FilePath& expected,
       const FilePath& path) {
     ++renamed_count_;
     EXPECT_EQ(expected_count, renamed_count_);
     EXPECT_EQ(expected.value(), path.value());
     return net::OK;
   }
 
  private:
   int renamed_count_;
 };
 
 // This is an observer that records what download IDs have opened a select
 // file dialog.
 class SelectFileObserver : public DownloadManager::Observer {
  public:
-  explicit SelectFileObserver(DownloadManager* download_manager)
+  explicit SelectFileObserver(DownloadManagerInterface* download_manager)
       : download_manager_(download_manager) {
     DCHECK(download_manager_.get());
     download_manager_->AddObserver(this);
   }
 
   ~SelectFileObserver() {
     download_manager_->RemoveObserver(this);
   }
 
   // Downloadmanager::Observer functions.
   virtual void ModelChanged() {}
   virtual void ManagerGoingDown() {}
   virtual void SelectFileDialogDisplayed(int32 id) {
     file_dialog_ids_.insert(id);
   }
 
   bool ShowedFileDialogForId(int32 id) {
     return file_dialog_ids_.find(id) != file_dialog_ids_.end();
   }
 
  private:
   std::set<int32> file_dialog_ids_;
-  scoped_refptr<DownloadManager> download_manager_;
+  scoped_refptr<DownloadManagerInterface> download_manager_;
 };
 
 // This observer tracks the progress of |DownloadItem|s.
 class ItemObserver : public DownloadItem::Observer {
  public:
   explicit ItemObserver(DownloadItem* tracked)
       : tracked_(tracked), states_hit_(0),
         was_updated_(false), was_opened_(false) {
     DCHECK(tracked_);
     tracked_->AddObserver(this);
@@ skipping 539 matching lines @@
   EXPECT_FALSE(observer->hit_state(DownloadItem::REMOVING));
   EXPECT_TRUE(observer->was_updated());
   EXPECT_FALSE(observer->was_opened());
   EXPECT_TRUE(download->file_externally_removed());
   EXPECT_EQ(DownloadItem::COMPLETE, download->state());
   EXPECT_EQ(download_item_model->GetStatusText(),
             l10n_util::GetStringUTF16(IDS_DOWNLOAD_STATUS_REMOVED));
 
   EXPECT_FALSE(file_util::PathExists(new_path));
 }