Rename the DownloadService to DownloadCoreService

chrome/browser/download/download_ui_controller_unittest.cc

 // Copyright 2013 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_ui_controller.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
+#include "chrome/browser/download/download_core_service_factory.h"
+#include "chrome/browser/download/download_core_service_impl.h"
 #include "chrome/browser/download/download_history.h"
-#include "chrome/browser/download/download_service_factory.h"
-#include "chrome/browser/download/download_service_impl.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "components/history/core/browser/download_row.h"
 #include "content/public/test/mock_download_item.h"
 #include "content/public/test/mock_download_manager.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gmock_mutant.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::MockDownloadItem;
@@ skipping 24 matching lines @@
 
 TestDelegate::TestDelegate(base::WeakPtr<content::DownloadItem*> receiver)
     : receiver_(receiver) {
 }
 
 void TestDelegate::OnNewDownloadReady(content::DownloadItem* item) {
   if (receiver_.get())
     *receiver_ = item;
 }
 
-// A DownloadService that returns a custom DownloadHistory.
-class TestDownloadService : public DownloadServiceImpl {
+// A DownloadCoreService that returns a custom DownloadHistory.
+class TestDownloadCoreService : public DownloadCoreServiceImpl {
  public:
-  explicit TestDownloadService(Profile* profile);
-  ~TestDownloadService() override;
+  explicit TestDownloadCoreService(Profile* profile);
+  ~TestDownloadCoreService() override;
 
   void set_download_history(std::unique_ptr<DownloadHistory> download_history) {
     download_history_.swap(download_history);
   }
   DownloadHistory* GetDownloadHistory() override;
 
  private:
   std::unique_ptr<DownloadHistory> download_history_;
 };
 
-TestDownloadService::TestDownloadService(Profile* profile)
-    : DownloadServiceImpl(profile) {
-}
+TestDownloadCoreService::TestDownloadCoreService(Profile* profile)
+    : DownloadCoreServiceImpl(profile) {}
 
-TestDownloadService::~TestDownloadService() {
-}
+TestDownloadCoreService::~TestDownloadCoreService() {}
 
-DownloadHistory* TestDownloadService::GetDownloadHistory() {
+DownloadHistory* TestDownloadCoreService::GetDownloadHistory() {
   return download_history_.get();
 }
 
 // The test fixture:
 class DownloadUIControllerTest : public ChromeRenderViewHostTestHarness {
  public:
   DownloadUIControllerTest();
 
  protected:
   // testing::Test
@@ skipping 36 matching lines @@
     HistoryAdapter() : DownloadHistory::HistoryAdapter(NULL) {}
     HistoryService::DownloadQueryCallback download_query_callback_;
 
    private:
     void QueryDownloads(
         const HistoryService::DownloadQueryCallback& callback) override {
       download_query_callback_ = callback;
     }
   };
 
-  // Constructs and returns a TestDownloadService.
-  static std::unique_ptr<KeyedService> TestingDownloadServiceFactory(
+  // Constructs and returns a TestDownloadCoreService.
+  static std::unique_ptr<KeyedService> TestingDownloadCoreServiceFactory(
       content::BrowserContext* browser_context);
 
   std::unique_ptr<MockDownloadManager> manager_;
   content::DownloadManager::Observer* download_history_manager_observer_;
   content::DownloadManager::Observer* manager_observer_;
   content::DownloadItem* notified_item_;
   base::WeakPtrFactory<content::DownloadItem*> notified_item_receiver_factory_;
 
   HistoryAdapter* history_adapter_;
 };
 
 // static
 std::unique_ptr<KeyedService>
-DownloadUIControllerTest::TestingDownloadServiceFactory(
+DownloadUIControllerTest::TestingDownloadCoreServiceFactory(
     content::BrowserContext* browser_context) {
-  return base::MakeUnique<TestDownloadService>(
+  return base::MakeUnique<TestDownloadCoreService>(
       Profile::FromBrowserContext(browser_context));
 }
 
 DownloadUIControllerTest::DownloadUIControllerTest()
     : download_history_manager_observer_(NULL),
       manager_observer_(NULL),
       notified_item_(NULL),
       notified_item_receiver_factory_(&notified_item_) {
 }
 
@@ skipping 17 matching lines @@
       new DownloadHistory(manager_.get(), std::move(history_adapter)));
   ASSERT_TRUE(download_history_manager_observer_);
 
   EXPECT_CALL(*manager_, AddObserver(_))
       .WillOnce(SaveArg<0>(&manager_observer_));
   EXPECT_CALL(*manager_,
               RemoveObserver(testing::Eq(testing::ByRef(manager_observer_))))
       .WillOnce(testing::Assign(
           &manager_observer_,
           static_cast<content::DownloadManager::Observer*>(NULL)));
-  TestDownloadService* download_service = static_cast<TestDownloadService*>(
-      DownloadServiceFactory::GetInstance()->SetTestingFactoryAndUse(
-          browser_context(), &TestingDownloadServiceFactory));
-  ASSERT_TRUE(download_service);
-  download_service->set_download_history(std::move(download_history));
+  TestDownloadCoreService* download_core_service =
+      static_cast<TestDownloadCoreService*>(
+          DownloadCoreServiceFactory::GetInstance()->SetTestingFactoryAndUse(
+              browser_context(), &TestingDownloadCoreServiceFactory));
+  ASSERT_TRUE(download_core_service);
+  download_core_service->set_download_history(std::move(download_history));
 }
 
 std::unique_ptr<MockDownloadItem>
 DownloadUIControllerTest::CreateMockInProgressDownload() {
   std::unique_ptr<MockDownloadItem> item(
       new testing::StrictMock<MockDownloadItem>());
   EXPECT_CALL(*item, GetBrowserContext())
       .WillRepeatedly(Return(browser_context()));
   EXPECT_CALL(*item, GetId()).WillRepeatedly(Return(1));
   EXPECT_CALL(*item, GetGuid())
@@ skipping 145 matching lines @@
   // DownloadUIController. It should ignore the download since it's marked as
   // being restored from history.
   ASSERT_TRUE(manager_observer());
   manager_observer()->OnDownloadCreated(manager(), item.get());
 
   // Finally, the expectation we've been waiting for:
   EXPECT_FALSE(notified_item());
 }
 
 } // namespace