Rename the DownloadService to DownloadCoreService

chrome/browser/ui/browser_close_unittest.cc

 // Copyright 2015 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 <stddef.h>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/download/chrome_download_manager_delegate.h"
-#include "chrome/browser/download/download_service.h"
-#include "chrome/browser/download/download_service_factory.h"
+#include "chrome/browser/download/download_core_service.h"
+#include "chrome/browser/download/download_core_service_factory.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/test/base/test_browser_window.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chrome/test/base/testing_profile_manager.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "extensions/features/features.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-class TestingDownloadService : public DownloadService {
+class TestingDownloadCoreService : public DownloadCoreService {
  public:
-  TestingDownloadService() : download_count_(0) {}
-  ~TestingDownloadService() override {}
+  TestingDownloadCoreService() : download_count_(0) {}
+  ~TestingDownloadCoreService() override {}
 
   // All methods that aren't expected to be called in the execution of
   // this unit test are marked to result in test failure.  Using a simple
   // mock for this class should be re-evaluated if any of these
   // methods are being called; it may mean that a more fully featured
-  // DownloadService implementation is needed.
+  // DownloadCoreService implementation is needed.
 
   void SetDownloadCount(int download_count) {
     download_count_ = download_count;
   }
 
-  // DownloadService
+  // DownloadCoreService
   ChromeDownloadManagerDelegate* GetDownloadManagerDelegate() override {
     ADD_FAILURE();
     return nullptr;
   }
 
   DownloadHistory* GetDownloadHistory() override {
     ADD_FAILURE();
     return nullptr;
   }
 
@@ skipping 18 matching lines @@
   bool IsShelfEnabled() override {
     return true;
   }
 
   // KeyedService
   void Shutdown() override {}
 
  private:
   int download_count_;
 
-  DISALLOW_COPY_AND_ASSIGN(TestingDownloadService);
+  DISALLOW_COPY_AND_ASSIGN(TestingDownloadCoreService);
 };
 
-static std::unique_ptr<KeyedService> CreateTestingDownloadService(
+static std::unique_ptr<KeyedService> CreateTestingDownloadCoreService(
     content::BrowserContext* browser_context) {
-  return std::unique_ptr<KeyedService>(new TestingDownloadService());
+  return std::unique_ptr<KeyedService>(new TestingDownloadCoreService());
 }
 
 class BrowserCloseTest : public testing::Test {
  public:
   BrowserCloseTest()
       : profile_manager_(TestingBrowserProcess::GetGlobal()), name_index_(0) {}
 
   ~BrowserCloseTest() override {}
 
   void SetUp() override { ASSERT_TRUE(profile_manager_.SetUp()); }
@@ skipping 40 matching lines @@
     CHECK(browsers_.end() != browsers_.find(profile));
     CHECK_GT(browsers_[profile].size(), static_cast<size_t>(index));
 
     return browsers_[profile][index];
   }
 
  private:
   void ConfigureCreatedProfile(Profile* profile,
                                int num_windows,
                                int num_downloads) {
-    DownloadServiceFactory::GetInstance()->SetTestingFactory(
-        profile, &CreateTestingDownloadService);
-    DownloadService* download_service(
-        DownloadServiceFactory::GetForBrowserContext(profile));
-    TestingDownloadService* mock_download_service(
-        static_cast<TestingDownloadService*>(download_service));
+    DownloadCoreServiceFactory::GetInstance()->SetTestingFactory(
+        profile, &CreateTestingDownloadCoreService);
+    DownloadCoreService* download_core_service(
+        DownloadCoreServiceFactory::GetForBrowserContext(profile));
+    TestingDownloadCoreService* mock_download_service(
+        static_cast<TestingDownloadCoreService*>(download_core_service));
     mock_download_service->SetDownloadCount(num_downloads);
 
     CHECK(browser_windows_.end() == browser_windows_.find(profile));
     CHECK(browsers_.end() == browsers_.find(profile));
 
     std::vector<TestBrowserWindow*> windows;
     std::vector<Browser*> browsers;
     for (int i = 0; i < num_windows; ++i) {
       TestBrowserWindow* window = new TestBrowserWindow();
       Browser::CreateParams params(profile, true);
@@ skipping 181 matching lines @@
   Profile* profile = CreateProfile(1, 0);
   Profile* incognito_profile = CreateIncognitoProfile(profile, 1, 2);
 
   Browser* browser = GetProfileBrowser(incognito_profile, 0);
 
   int num_downloads_blocking = 0;
   EXPECT_EQ(Browser::DOWNLOAD_CLOSE_LAST_WINDOW_IN_INCOGNITO_PROFILE,
             browser->OkToCloseWithInProgressDownloads(&num_downloads_blocking));
   EXPECT_EQ(2, num_downloads_blocking);
 }