BrowserContext should simply own DownloadManager

chrome/browser/download/download_status_updater_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 "base/memory/scoped_ptr.h"
+#include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "chrome/browser/download/download_status_updater.h"
 #include "content/public/test/mock_download_item.h"
 #include "content/public/test/mock_download_manager.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 56 matching lines @@
     loop_.RunUntilIdle();  // Allow DownloadManager destruction.
   }
 
  protected:
   // Attach some number of DownloadManagers to the updater.
   void SetupManagers(int manager_count) {
     DCHECK_EQ(0U, managers_.size());
     for (int i = 0; i < manager_count; ++i) {
       content::MockDownloadManager* mgr =
           new StrictMock<content::MockDownloadManager>;
-      managers_.push_back(make_scoped_refptr(mgr));
+      managers_.push_back(mgr);
     }
   }
 
   void SetObserver(content::DownloadManager::Observer* observer) {
     manager_observers_[manager_observer_index_] = observer;
   }
 
   // Hook the specified manager into the updater.
   void LinkManager(int i) {
-    content::MockDownloadManager* mgr = managers_[i].get();
+    content::MockDownloadManager* mgr = managers_[i];
     manager_observer_index_ = i;
     while (manager_observers_.size() <= static_cast<size_t>(i)) {
       manager_observers_.push_back(NULL);
     }
     EXPECT_CALL(*mgr, AddObserver(_))
         .WillOnce(WithArg<0>(Invoke(
             this, &DownloadStatusUpdaterTest::SetObserver)));
     updater_->AddManager(mgr);
   }
 
   // Add some number of Download items to a particular manager.
   void AddItems(int manager_index, int item_count, int in_progress_count) {
     DCHECK_GT(managers_.size(), static_cast<size_t>(manager_index));
-    content::MockDownloadManager* manager = managers_[manager_index].get();
+    content::MockDownloadManager* manager = managers_[manager_index];
 
     if (manager_items_.size() <= static_cast<size_t>(manager_index))
       manager_items_.resize(manager_index+1);
 
     std::vector<content::DownloadItem*> item_list;
     for (int i = 0; i < item_count; ++i) {
       content::MockDownloadItem* item =
           new StrictMock<content::MockDownloadItem>;
       content::DownloadItem::DownloadState state =
           i < in_progress_count ? content::DownloadItem::IN_PROGRESS
               : content::DownloadItem::CANCELLED;
       EXPECT_CALL(*item, GetState()).WillRepeatedly(Return(state));
       EXPECT_CALL(*item, AddObserver(_))
           .WillOnce(Return());
       manager_items_[manager_index].push_back(item);
     }
     EXPECT_CALL(*manager, GetAllDownloads(_))
         .WillRepeatedly(SetArgPointee<0>(manager_items_[manager_index]));
   }
 
   // Return the specified manager.
   content::MockDownloadManager* Manager(int manager_index) {
     DCHECK_GT(managers_.size(), static_cast<size_t>(manager_index));
-    return managers_[manager_index].get();
+    return managers_[manager_index];
   }
 
   // Return the specified item.
   content::MockDownloadItem* Item(int manager_index, int item_index) {
     DCHECK_GT(manager_items_.size(), static_cast<size_t>(manager_index));
     DCHECK_GT(manager_items_[manager_index].size(),
               static_cast<size_t>(item_index));
     // All DownloadItems in manager_items_ are MockDownloadItems.
     return static_cast<content::MockDownloadItem*>(
         manager_items_[manager_index][item_index]);
@@ skipping 15 matching lines @@
   // Transition specified item to completed.
   void CompleteItem(int manager_index, int item_index) {
     content::MockDownloadItem* item(Item(manager_index, item_index));
     EXPECT_CALL(*item, GetState())
         .WillRepeatedly(Return(content::DownloadItem::COMPLETE));
     updater_->OnDownloadUpdated(managers_[manager_index], item);
   }
 
   // Verify and clear all mocks expectations.
   void VerifyAndClearExpectations() {
-    for (std::vector<scoped_refptr<content::MockDownloadManager> >::iterator it
+    for (ScopedVector<content::MockDownloadManager>::iterator it
              = managers_.begin(); it != managers_.end(); ++it)
-      Mock::VerifyAndClearExpectations(it->get());
+      Mock::VerifyAndClearExpectations(*it);
     for (std::vector<Items>::iterator it = manager_items_.begin();
          it != manager_items_.end(); ++it)
       for (Items::iterator sit = it->begin(); sit != it->end(); ++sit)
         Mock::VerifyAndClearExpectations(*sit);
   }
 
-  std::vector<scoped_refptr<content::MockDownloadManager> > managers_;
+  ScopedVector<content::MockDownloadManager> managers_;
   // DownloadItem so that it can be assigned to the result of SearchDownloads.
   typedef std::vector<content::DownloadItem*> Items;
   std::vector<Items> manager_items_;
   int manager_observer_index_;
 
   std::vector<content::DownloadManager::Observer*> manager_observers_;
 
   // Pointer so we can verify that destruction triggers appropriate
   // changes.
   TestDownloadStatusUpdater *updater_;
@@ skipping 17 matching lines @@
 
 // Test updater with null manager.
 TEST_F(DownloadStatusUpdaterTest, OneManagerNoItems) {
   SetupManagers(1);
   AddItems(0, 0, 0);
   LinkManager(0);
   VerifyAndClearExpectations();
 
   float progress = -1;
   int download_count = -1;
-  EXPECT_CALL(*managers_[0].get(), GetAllDownloads(_))
+  EXPECT_CALL(*managers_[0], GetAllDownloads(_))
       .WillRepeatedly(SetArgPointee<0>(manager_items_[0]));
   EXPECT_TRUE(updater_->GetProgress(&progress, &download_count));
   EXPECT_FLOAT_EQ(0.0f, progress);
   EXPECT_EQ(0, download_count);
 }
 
 // Test updater with non-null manager, including transition an item to
 // |content::DownloadItem::COMPLETE| and adding a new item.
 TEST_F(DownloadStatusUpdaterTest, OneManagerManyItems) {
   SetupManagers(1);
@@ skipping 116 matching lines @@
   SetItemValues(0, 0, 10, 20, false);
   SetItemValues(0, 1, 50, 60, false);
   SetItemValues(1, 0, 80, 90, false);
 
   float progress = -1;
   int download_count = -1;
   EXPECT_TRUE(updater_->GetProgress(&progress, &download_count));
   EXPECT_FLOAT_EQ((10+50+80)/(20.0f+60+90), progress);
   EXPECT_EQ(3, download_count);
 }