Remove WebUnitTestSupport

content/child/notifications/pending_notifications_tracker_unittest.cc

 // Copyright 2016 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 "content/child/notifications/pending_notifications_tracker.h"
 
 #include <vector>
 
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/common/notification_constants.h"
 #include "content/public/common/notification_resources.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/Platform.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/platform/WebURLError.h"
+#include "third_party/WebKit/public/platform/WebURLLoaderMockFactory.h"
 #include "third_party/WebKit/public/platform/WebURLResponse.h"
-#include "third_party/WebKit/public/platform/WebUnitTestSupport.h"
 #include "third_party/WebKit/public/platform/modules/notifications/WebNotificationData.h"
 #include "third_party/WebKit/public/platform/modules/notifications/WebNotificationDelegate.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "url/gurl.h"
 
 namespace content {
 
 namespace {
 
 const char kBaseUrl[] = "http://test.com/";
@@ skipping 13 matching lines @@
 
 }  // namespace
 
 class PendingNotificationsTrackerTest : public testing::Test {
  public:
   PendingNotificationsTrackerTest()
       : tracker_(new PendingNotificationsTracker(
             base::ThreadTaskRunnerHandle::Get())) {}
 
   ~PendingNotificationsTrackerTest() override {
-    UnitTestSupport()->unregisterAllMockedURLs();
+    GetURLLoaderMockFactory()->unregisterAllURLs();
   }
 
   void DidFetchResources(size_t index, const NotificationResources& resources) {
     if (resources_.size() < index + 1)
       resources_.resize(index + 1);
     resources_[index] = resources;
   }
 
  protected:
   PendingNotificationsTracker* tracker() { return tracker_.get(); }
 
   size_t CountResources() { return resources_.size(); }
 
   NotificationResources* GetResources(size_t index) {
     DCHECK_LT(index, resources_.size());
     return &resources_[index];
   }
 
   size_t CountPendingNotifications() {
     return tracker_->pending_notifications_.size();
   }
 
   size_t CountDelegates() {
     return tracker_->delegate_to_pending_id_map_.size();
   }
 
-  blink::WebUnitTestSupport* UnitTestSupport() {
-    return blink::Platform::current()->unitTestSupport();
+  blink::WebURLLoaderMockFactory* GetURLLoaderMockFactory() {
+    return blink::Platform::current()->getURLLoaderMockFactory();
   }
 
   // Registers a mocked url. When fetched, |file_name| will be loaded from the
   // test data directory.
   blink::WebURL RegisterMockedURL(const std::string& file_name) {
     blink::WebURL url(GURL(kBaseUrl + file_name));
 
     blink::WebURLResponse response(url);
     response.setMIMEType("image/png");
     response.setHTTPStatusCode(200);
 
     base::FilePath file_path;
     base::PathService::Get(base::DIR_SOURCE_ROOT, &file_path);
     file_path = file_path.Append(FILE_PATH_LITERAL("content"))
                     .Append(FILE_PATH_LITERAL("test"))
                     .Append(FILE_PATH_LITERAL("data"))
                     .Append(FILE_PATH_LITERAL("notifications"))
                     .AppendASCII(file_name);
     file_path = base::MakeAbsoluteFilePath(file_path);
     blink::WebString string_file_path =
         blink::WebString::fromUTF8(file_path.MaybeAsASCII());
 
-    UnitTestSupport()->registerMockedURL(url, response, string_file_path);
+    GetURLLoaderMockFactory()->registerURL(url, response, string_file_path);
 
     return url;
   }
 
   // Registers a mocked url that will fail to be fetched, with a 404 error.
   blink::WebURL RegisterMockedErrorURL(const std::string& file_name) {
     blink::WebURL url(GURL(kBaseUrl + file_name));
 
     blink::WebURLResponse response(url);
     response.setMIMEType("image/png");
     response.setHTTPStatusCode(404);
 
     blink::WebURLError error;
     error.reason = 404;
 
-    UnitTestSupport()->registerMockedErrorURL(url, response, error);
+    GetURLLoaderMockFactory()->registerErrorURL(url, response, error);
     return url;
   }
 
  private:
   base::MessageLoop message_loop_;
   scoped_ptr<PendingNotificationsTracker> tracker_;
   std::vector<NotificationResources> resources_;
 
   DISALLOW_COPY_AND_ASSIGN(PendingNotificationsTrackerTest);
 };
 
 TEST_F(PendingNotificationsTrackerTest, OneNotificationMultipleResources) {
   blink::WebNotificationData notification_data;
   notification_data.icon = RegisterMockedURL(kIcon100x100);
   notification_data.badge = RegisterMockedURL(kIcon48x48);
   notification_data.actions =
       blink::WebVector<blink::WebNotificationAction>(static_cast<size_t>(2));
   notification_data.actions[0].icon = RegisterMockedURL(kIcon110x110);
   notification_data.actions[1].icon = RegisterMockedURL(kIcon120x120);
 
   tracker()->FetchResources(
       notification_data, nullptr /* delegate */,
       base::Bind(&PendingNotificationsTrackerTest::DidFetchResources,
                  base::Unretained(this), 0 /* index */));
 
   ASSERT_EQ(1u, CountPendingNotifications());
   ASSERT_EQ(0u, CountResources());
 
   base::RunLoop().RunUntilIdle();
-  UnitTestSupport()->serveAsynchronousMockedRequests();
+  GetURLLoaderMockFactory()->serveAsynchronousRequests();
 
   ASSERT_EQ(0u, CountPendingNotifications());
   ASSERT_EQ(1u, CountResources());
 
   NotificationResources* resources = GetResources(0u);
 
   ASSERT_FALSE(resources->notification_icon.drawsNothing());
   ASSERT_EQ(100, resources->notification_icon.width());
 
   ASSERT_FALSE(resources->badge.drawsNothing());
@@ skipping 16 matching lines @@
 
   tracker()->FetchResources(
       notification_data, nullptr /* delegate */,
       base::Bind(&PendingNotificationsTrackerTest::DidFetchResources,
                  base::Unretained(this), 0 /* index */));
 
   ASSERT_EQ(1u, CountPendingNotifications());
   ASSERT_EQ(0u, CountResources());
 
   base::RunLoop().RunUntilIdle();
-  UnitTestSupport()->serveAsynchronousMockedRequests();
+  GetURLLoaderMockFactory()->serveAsynchronousRequests();
 
   ASSERT_EQ(0u, CountPendingNotifications());
   ASSERT_EQ(1u, CountResources());
 
   NotificationResources* resources = GetResources(0u);
 
   ASSERT_FALSE(resources->notification_icon.drawsNothing());
   ASSERT_EQ(kPlatformNotificationMaxIconSizePx,
             resources->notification_icon.width());
   ASSERT_EQ(kPlatformNotificationMaxIconSizePx,
@@ skipping 25 matching lines @@
 
   tracker()->FetchResources(
       notification_data_2, nullptr /* delegate */,
       base::Bind(&PendingNotificationsTrackerTest::DidFetchResources,
                  base::Unretained(this), 1 /* index */));
 
   ASSERT_EQ(2u, CountPendingNotifications());
   ASSERT_EQ(0u, CountResources());
 
   base::RunLoop().RunUntilIdle();
-  UnitTestSupport()->serveAsynchronousMockedRequests();
+  GetURLLoaderMockFactory()->serveAsynchronousRequests();
 
   ASSERT_EQ(0u, CountPendingNotifications());
   ASSERT_EQ(2u, CountResources());
 
   ASSERT_FALSE(GetResources(0u)->notification_icon.drawsNothing());
   ASSERT_EQ(100, GetResources(0u)->notification_icon.width());
 
   ASSERT_FALSE(GetResources(1u)->notification_icon.drawsNothing());
   ASSERT_EQ(110, GetResources(1u)->notification_icon.width());
 }
 
 TEST_F(PendingNotificationsTrackerTest, FetchError) {
   blink::WebNotificationData notification_data;
   notification_data.icon = RegisterMockedErrorURL(kIcon100x100);
 
   tracker()->FetchResources(
       notification_data, nullptr /* delegate */,
       base::Bind(&PendingNotificationsTrackerTest::DidFetchResources,
                  base::Unretained(this), 0 /* index */));
 
   ASSERT_EQ(1u, CountPendingNotifications());
   ASSERT_EQ(0u, CountResources());
 
   base::RunLoop().RunUntilIdle();
-  UnitTestSupport()->serveAsynchronousMockedRequests();
+  GetURLLoaderMockFactory()->serveAsynchronousRequests();
 
   ASSERT_EQ(0u, CountPendingNotifications());
   ASSERT_EQ(1u, CountResources());
 
   ASSERT_TRUE(GetResources(0u)->notification_icon.drawsNothing());
 }
 
 TEST_F(PendingNotificationsTrackerTest, CancelFetches) {
   blink::WebNotificationData notification_data;
   notification_data.icon = RegisterMockedURL(kIcon100x100);
@@ skipping 11 matching lines @@
 
   base::RunLoop().RunUntilIdle();
   tracker()->CancelResourceFetches(&delegate);
 
   ASSERT_EQ(0u, CountPendingNotifications());
   ASSERT_EQ(0u, CountDelegates());
   ASSERT_EQ(0u, CountResources());
 }
 
 }  // namespace content