Split FaviconService and FaviconServiceImpl.

ios/chrome/app/spotlight/spotlight_manager_unittest.mm

 // 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 <memory>
 
 #import <CoreSpotlight/CoreSpotlight.h>
 #import <Foundation/Foundation.h>
 
 #include "base/location.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/test/bookmark_test_helpers.h"
 #include "components/bookmarks/test/test_bookmark_client.h"
-#include "components/favicon/core/favicon_client.h"
-#include "components/favicon/core/favicon_service.h"
 #include "components/favicon/core/large_icon_service.h"
+#include "components/favicon/core/test/mock_favicon_service.h"
 #include "components/favicon_base/fallback_icon_style.h"
 #import "ios/chrome/app/spotlight/bookmarks_spotlight_manager.h"
 #import "ios/chrome/app/spotlight/spotlight_manager.h"
 #import "ios/chrome/app/spotlight/spotlight_util.h"
 #include "ios/chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "ios/public/provider/chrome/browser/chrome_browser_provider.h"
 #include "ios/public/provider/chrome/browser/spotlight/spotlight_provider.h"
 #import "net/base/mac/url_conversions.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/gtest_mac.h"
 
 #if !defined(__has_feature) || !__has_feature(objc_arc)
 #error "This file requires ARC support."
 #endif
 
+using favicon::PostCallbackWithResult;
+using testing::WithArg;
+using testing::_;
+
 const char kDummyIconUrl[] = "http://www.example.com/touch_icon.png";
 
 favicon_base::FaviconRawBitmapResult CreateTestBitmap(int w, int h) {
   favicon_base::FaviconRawBitmapResult result;
   result.expired = false;
 
   CGRect rect = CGRectMake(0, 0, w, h);
   UIGraphicsBeginImageContext(rect.size);
   CGContextRef context = UIGraphicsGetCurrentContext();
   CGContextFillRect(context, rect);
   UIImage* favicon = UIGraphicsGetImageFromCurrentImageContext();
   UIGraphicsEndImageContext();
 
   NSData* png = UIImagePNGRepresentation(favicon);
   scoped_refptr<base::RefCountedBytes> data(new base::RefCountedBytes(
       static_cast<const unsigned char*>([png bytes]), [png length]));
 
   result.bitmap_data = data;
   result.pixel_size = gfx::Size(w, h);
   result.icon_url = GURL(kDummyIconUrl);
   result.icon_type = favicon_base::TOUCH_ICON;
   CHECK(result.is_valid());
   return result;
 }
 
-// A mock FaviconService that emits pre-programmed response.
-class MockFaviconService : public favicon::FaviconService {
- public:
-  MockFaviconService() : FaviconService(nullptr, nullptr) {}
-
-  ~MockFaviconService() override {}
-
-  base::CancelableTaskTracker::TaskId GetLargestRawFaviconForPageURL(
-      const GURL& page_url,
-      const std::vector<int>& icon_types,
-      int minimum_size_in_pixels,
-      const favicon_base::FaviconRawBitmapCallback& callback,
-      base::CancelableTaskTracker* tracker) override {
-    favicon_base::FaviconRawBitmapResult mock_result = CreateTestBitmap(24, 24);
-    return tracker->PostTask(base::ThreadTaskRunnerHandle::Get().get(),
-                             FROM_HERE, base::Bind(callback, mock_result));
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(MockFaviconService);
-};
-
-// This class provides access to LargeIconService internals, using the current
-// thread's task runner for testing.
-class TestLargeIconService : public favicon::LargeIconService {
- public:
-  explicit TestLargeIconService(MockFaviconService* mock_favicon_service)
-      : LargeIconService(mock_favicon_service,
-                         base::ThreadTaskRunnerHandle::Get()) {}
-  ~TestLargeIconService() override {}
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(TestLargeIconService);
-};
-
 class SpotlightManagerTest : public testing::Test {
  protected:
   SpotlightManagerTest() {
-    mock_favicon_service_.reset(new MockFaviconService());
-    large_icon_service_.reset(
-        new TestLargeIconService(mock_favicon_service_.get()));
     model_ = bookmarks::TestBookmarkClient::CreateModel();
-    mock_favicon_service_.reset(new MockFaviconService());
-    large_icon_service_.reset(
-        new TestLargeIconService(mock_favicon_service_.get()));
+    large_icon_service_.reset(new favicon::LargeIconService(
+        &mock_favicon_service_, base::ThreadTaskRunnerHandle::Get()));
     bookmarksSpotlightManager_ = [[BookmarksSpotlightManager alloc]
         initWithLargeIconService:large_icon_service_.get()
                    bookmarkModel:model_.get()];
+
+    EXPECT_CALL(mock_favicon_service_,
+                GetLargestRawFaviconForPageURL(_, _, _, _, _))
+        .WillRepeatedly(
+            WithArg<3>(PostCallbackWithResult(CreateTestBitmap(24, 24))));

[pkotwicz, 2017/02/16 04:07:27]

This is ok because there aren't a lot of places where we implement
FaviconService methods via the EXPECT_CALL() macro. However, I wouldn't want to
implement FaviconService via the EXPECT_CALL macro in many dozens of places.

[mastiz, 2017/02/16 09:46:25]

The upside is, only a single method can be implemented. It also allows tests to
optionally specify parameter expectations, as it is the case today in
favicon_view_provider_unittest.mm, which wants to verify that the passed in URL
is kTestFaviconURL.

   }
 
   base::MessageLoop loop_;
-  std::unique_ptr<MockFaviconService> mock_favicon_service_;
-  std::unique_ptr<TestLargeIconService> large_icon_service_;
+  testing::StrictMock<favicon::MockFaviconService> mock_favicon_service_;
+  std::unique_ptr<favicon::LargeIconService> large_icon_service_;
   base::CancelableTaskTracker cancelable_task_tracker_;
   std::unique_ptr<bookmarks::BookmarkModel> model_;
   BookmarksSpotlightManager* bookmarksSpotlightManager_;
 };
 
 TEST_F(SpotlightManagerTest, testSpotlightID) {
   // Creating CSSearchableItem requires Spotlight to be available on the device.
   if (!spotlight::IsSpotlightAvailable())
     return;
   GURL url("http://url.com");
@@ skipping 73 matching lines @@
   NSSet* spotlightManagerKeywords =
       [NSSet setWithArray:[[item attributeSet] keywords]];
   EXPECT_TRUE([spotlightManagerKeywords count] > 0);
   // Check static/hardcoded keywords exist
   NSSet* hardCodedKeywordsSet =
       [NSSet setWithArray:ios::GetChromeBrowserProvider()
                               ->GetSpotlightProvider()
                               ->GetAdditionalKeywords()];
   EXPECT_TRUE([hardCodedKeywordsSet isSubsetOfSet:spotlightManagerKeywords]);
 }