Migrate PrefetchRequestFetcher to using SimpleURLLoader

URLFetcher will stop working with advent of Network Service, and
SimpleURLLoader is the replacement API for most clients.
This CL migrates PrefetchRequestFetcher et al and the
respective unittests away from URLFetcher.

Bug: 773295,879776
Change-Id: Ibcfc2a7d72b6efe1b372233ade95b58d95fbf62b
Reviewed-on: https://chromium-review.googlesource.com/1215367Reviewed-by: Justin DeWitt <dewittj@chromium.org>
Reviewed-by: Matt Menke <mmenke@chromium.org>
Commit-Queue: Antonio Gomes <tonikitoo@igalia.com>
Cr-Commit-Position: refs/heads/master@{#590048}

chrome/browser/offline_pages/prefetch/prefetch_service_factory.cc

@@ -33,6 +33,7 @@
 #include "components/offline_pages/core/prefetch/store/prefetch_store.h"
 #include "components/offline_pages/core/prefetch/suggested_articles_observer.h"
 #include "content/public/browser/browser_context.h"
+#include "services/network/public/cpp/shared_url_loader_factory.h"
 
 namespace offline_pages {
 
@@ -75,7 +76,7 @@ KeyedService* PrefetchServiceFactory::BuildServiceInstanceFor(
 
   auto prefetch_network_request_factory =
       std::make_unique<PrefetchNetworkRequestFactoryImpl>(
-          profile->GetRequestContext(), chrome::GetChannel(), GetUserAgent());
+          profile->GetURLLoaderFactory(), chrome::GetChannel(), GetUserAgent());
 
   scoped_refptr<base::SequencedTaskRunner> background_task_runner =
       base::CreateSequencedTaskRunnerWithTraits({base::MayBlock()});

components/offline_pages/core/prefetch/BUILD.gn

@@ -111,6 +111,7 @@ static_library("prefetch") {
     "//components/version_info",
     "//google_apis",
     "//net:net",
+    "//services/network/public/cpp:cpp",
     "//sql:sql",
     "//url",
   ]
@@ -168,6 +169,7 @@ static_library("test_support") {
     "//components/prefs:test_support",
     "//components/version_info:channel",
     "//net:test_support",
+    "//services/network:test_support",
     "//sql:sql",
     "//testing/gmock",
     "//url",
@@ -248,6 +250,7 @@ source_set("unit_tests") {
     "//components/variations:test_support",
     "//components/version_info:channel",
     "//net:test_support",
+    "//services/network:test_support",
     "//sql:sql",
     "//testing/gmock",
     "//testing/gtest",

components/offline_pages/core/prefetch/DEPS

@@ -7,5 +7,7 @@ include_rules = [
   "+components/ntp_snippets",
   "+components/version_info",
   "+net",
+  "+services/network/public/cpp",
+  "+services/network/test",
   "+sql",
 ]

components/offline_pages/core/prefetch/generate_page_bundle_request.cc

@@ -11,7 +11,7 @@
 #include "components/offline_pages/core/prefetch/prefetch_request_fetcher.h"
 #include "components/offline_pages/core/prefetch/prefetch_server_urls.h"
 #include "components/offline_pages/core/prefetch/proto/offline_pages.pb.h"
-#include "net/url_request/url_request_context_getter.h"
+#include "services/network/public/cpp/shared_url_loader_factory.h"
 #include "url/gurl.h"
 
 namespace offline_pages {
@@ -22,7 +22,7 @@ GeneratePageBundleRequest::GeneratePageBundleRequest(
     int max_bundle_size_bytes,
     const std::vector<std::string>& page_urls,
     version_info::Channel channel,
-    net::URLRequestContextGetter* request_context_getter,
+    scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
     PrefetchRequestFinishedCallback callback)
     : callback_(std::move(callback)), requested_urls_(page_urls) {
   proto::GeneratePageBundleRequest request;
@@ -41,8 +41,7 @@ GeneratePageBundleRequest::GeneratePageBundleRequest(
   request.SerializeToString(&upload_data);
 
   fetcher_ = PrefetchRequestFetcher::CreateForPost(
-      GeneratePageBundleRequestURL(channel), upload_data,
-      request_context_getter,
+      GeneratePageBundleRequestURL(channel), upload_data, url_loader_factory,
       base::BindOnce(&GeneratePageBundleRequest::OnCompleted,
                      // Fetcher is owned by this instance.
                      base::Unretained(this)));

components/offline_pages/core/prefetch/generate_page_bundle_request.h

@@ -13,8 +13,8 @@
 #include "components/offline_pages/core/prefetch/prefetch_types.h"
 #include "components/version_info/channel.h"
 
-namespace net {
-class URLRequestContextGetter;
+namespace network {
+class SharedURLLoaderFactory;
 }
 
 namespace offline_pages {
@@ -29,7 +29,7 @@ class GeneratePageBundleRequest {
       int max_bundle_size_bytes,
       const std::vector<std::string>& page_urls,
       version_info::Channel channel,
-      net::URLRequestContextGetter* request_context_getter,
+      scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
       PrefetchRequestFinishedCallback callback);
   ~GeneratePageBundleRequest();
 

components/offline_pages/core/prefetch/generate_page_bundle_request_unittest.cc

@@ -10,6 +10,7 @@
 #include "components/offline_pages/core/prefetch/proto/offline_pages.pb.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_request_status.h"
+#include "services/network/test/test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "url/gurl.h"
 #include "url/url_constants.h"
@@ -43,7 +44,7 @@ class GeneratePageBundleRequestTest : public PrefetchRequestTestBase {
     return std::unique_ptr<GeneratePageBundleRequest>(
         new GeneratePageBundleRequest(
             kTestUserAgent, kTestGCMID, kTestMaxBundleSize, page_urls,
-            kTestChannel, request_context(), std::move(callback)));
+            kTestChannel, shared_url_loader_factory(), std::move(callback)));
   }
 };
 
@@ -56,19 +57,26 @@ TEST_F(GeneratePageBundleRequestTest, RequestData) {
   EXPECT_THAT(request->requested_urls(), Contains(kTestURL));
   EXPECT_THAT(request->requested_urls(), Contains(kTestURL2));
 
-  net::TestURLFetcher* fetcher = GetRunningFetcher();
-  EXPECT_TRUE(fetcher->GetOriginalURL().SchemeIs(url::kHttpsScheme));
-  EXPECT_TRUE(base::StartsWith(fetcher->GetOriginalURL().query(), "key",
+  network::TestURLLoaderFactory::PendingRequest* pending_request =
+      GetPendingRequest();
+  DCHECK(pending_request);
+  GURL request_url = pending_request->request.url;
+  EXPECT_TRUE(request_url.SchemeIs(url::kHttpsScheme));
+  EXPECT_TRUE(base::StartsWith(request_url.query(), "key",
                                base::CompareCase::SENSITIVE));
 
-  EXPECT_FALSE(fetcher->upload_content_type().empty());
-  EXPECT_FALSE(fetcher->upload_data().empty());
+  std::string upload_content_type;
+  pending_request->request.headers.GetHeader(
+      net::HttpRequestHeaders::kContentType, &upload_content_type);
+  EXPECT_FALSE(upload_content_type.empty());
+  EXPECT_FALSE(network::GetUploadData(pending_request->request).empty());
 
   // Experiment header should not be set.
-  EXPECT_EQ("", GetExperiementHeaderValue(fetcher));
+  EXPECT_EQ("", GetExperiementHeaderValue(pending_request));
 
   proto::GeneratePageBundleRequest bundle_data;
-  ASSERT_TRUE(bundle_data.ParseFromString(fetcher->upload_data()));
+  ASSERT_TRUE(bundle_data.ParseFromString(
+      network::GetUploadData(pending_request->request)));
   EXPECT_EQ(kTestUserAgent, bundle_data.user_agent());
   EXPECT_EQ(proto::FORMAT_MHTML, bundle_data.output_format());
   EXPECT_EQ(kTestMaxBundleSize, bundle_data.max_bundle_size_bytes());
@@ -87,11 +95,13 @@ TEST_F(GeneratePageBundleRequestTest, ExperimentHeaderInRequestData) {
   base::MockCallback<PrefetchRequestFinishedCallback> callback;
   std::unique_ptr<GeneratePageBundleRequest> request(
       CreateRequest(callback.Get()));
-  net::TestURLFetcher* fetcher = GetRunningFetcher();
+  network::TestURLLoaderFactory::PendingRequest* pending_request =
+      GetPendingRequest();
+  DCHECK(pending_request);
 
   // Experiment header should be set.
   EXPECT_EQ(kExperimentValueSetInFieldTrial,
-            GetExperiementHeaderValue(fetcher));
+            GetExperiementHeaderValue(pending_request));
 }
 
 TEST_F(GeneratePageBundleRequestTest, EmptyResponse) {
@@ -106,6 +116,7 @@ TEST_F(GeneratePageBundleRequestTest, EmptyResponse) {
       .WillOnce(DoAll(SaveArg<0>(&status), SaveArg<1>(&operation_name),
                       SaveArg<2>(&pages)));
   RespondWithData("");
+  RunUntilIdle();
 
   EXPECT_EQ(PrefetchRequestStatus::SHOULD_RETRY_WITH_BACKOFF, status);
   EXPECT_TRUE(operation_name.empty());
@@ -124,6 +135,7 @@ TEST_F(GeneratePageBundleRequestTest, InvalidResponse) {
       .WillOnce(DoAll(SaveArg<0>(&status), SaveArg<1>(&operation_name),
                       SaveArg<2>(&pages)));
   RespondWithData("Some invalid data");
+  RunUntilIdle();
 
   EXPECT_EQ(PrefetchRequestStatus::SHOULD_RETRY_WITH_BACKOFF, status);
   EXPECT_TRUE(operation_name.empty());

components/offline_pages/core/prefetch/generate_page_bundle_task_unittest.cc

@@ -19,6 +19,7 @@
 #include "components/offline_pages/core/prefetch/test_prefetch_dispatcher.h"
 #include "components/offline_pages/core/prefetch/test_prefetch_gcm_handler.h"
 #include "components/offline_pages/task/task.h"
+#include "services/network/test/test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -127,7 +128,7 @@ TEST_F(GeneratePageBundleTaskTest, TaskMakesNetworkRequest) {
   EXPECT_THAT(*requested_urls, Not(Contains(item3.url.spec())));
 
   std::string upload_data =
-      url_fetcher_factory()->GetFetcherByID(0)->upload_data();
+      network::GetUploadData(GetPendingRequest(0 /*index*/)->request);
   EXPECT_THAT(upload_data, HasSubstr(MockPrefetchItemGenerator::kUrlPrefix));
 
   EXPECT_EQ(3, store_util()->CountPrefetchItems());

components/offline_pages/core/prefetch/get_operation_request.cc

@@ -10,7 +10,7 @@
 #include "components/offline_pages/core/prefetch/prefetch_proto_utils.h"
 #include "components/offline_pages/core/prefetch/prefetch_request_fetcher.h"
 #include "components/offline_pages/core/prefetch/prefetch_server_urls.h"
-#include "net/url_request/url_request_context_getter.h"
+#include "services/network/public/cpp/shared_url_loader_factory.h"
 #include "url/gurl.h"
 
 namespace offline_pages {
@@ -18,11 +18,11 @@ namespace offline_pages {
 GetOperationRequest::GetOperationRequest(
     const std::string& name,
     version_info::Channel channel,
-    net::URLRequestContextGetter* request_context_getter,
+    scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
     PrefetchRequestFinishedCallback callback)
     : callback_(std::move(callback)) {
   fetcher_ = PrefetchRequestFetcher::CreateForGet(
-      GetOperationRequestURL(name, channel), request_context_getter,
+      GetOperationRequestURL(name, channel), url_loader_factory,
       base::BindOnce(&GetOperationRequest::OnCompleted,
                      // Fetcher is owned by this instance.
                      base::Unretained(this), name));

components/offline_pages/core/prefetch/get_operation_request.h

@@ -12,8 +12,8 @@
 #include "components/offline_pages/core/prefetch/prefetch_types.h"
 #include "components/version_info/channel.h"
 
-namespace net {
-class URLRequestContextGetter;
+namespace network {
+class SharedURLLoaderFactory;
 }
 
 namespace offline_pages {
@@ -27,10 +27,11 @@ class GetOperationRequest {
   // |name| identifies the operation triggered by the GeneratePageBundleRequest.
   // It is retrieved from the operation data returned in the
   // GeneratePageBundleRequest response.
-  GetOperationRequest(const std::string& name,
-                      version_info::Channel channel,
-                      net::URLRequestContextGetter* request_context_getter,
-                      PrefetchRequestFinishedCallback callback);
+  GetOperationRequest(
+      const std::string& name,
+      version_info::Channel channel,
+      scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
+      PrefetchRequestFinishedCallback callback);
   ~GetOperationRequest();
 
  private:

components/offline_pages/core/prefetch/get_operation_request_unittest.cc

@@ -10,6 +10,7 @@
 #include "components/offline_pages/core/prefetch/proto/offline_pages.pb.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_request_status.h"
+#include "services/network/test/test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "url/gurl.h"
 #include "url/url_constants.h"
@@ -39,9 +40,9 @@ class GetOperationRequestTest : public PrefetchRequestTestBase {
  public:
   std::unique_ptr<GetOperationRequest> CreateRequest(
       PrefetchRequestFinishedCallback callback) {
-    return std::unique_ptr<GetOperationRequest>(
-        new GetOperationRequest(kTestOperationName, kTestChannel,
-                                request_context(), std::move(callback)));
+    return std::unique_ptr<GetOperationRequest>(new GetOperationRequest(
+        kTestOperationName, kTestChannel, shared_url_loader_factory(),
+        std::move(callback)));
   }
 };
 
@@ -49,25 +50,28 @@ TEST_F(GetOperationRequestTest, RequestData) {
   base::MockCallback<PrefetchRequestFinishedCallback> callback;
   std::unique_ptr<GetOperationRequest> request(CreateRequest(callback.Get()));
 
-  net::TestURLFetcher* fetcher = GetRunningFetcher();
-  GURL fetcher_url = fetcher->GetOriginalURL();
-  EXPECT_TRUE(fetcher_url.SchemeIs(url::kHttpsScheme));
-  EXPECT_EQ(kServerPathForTestOperation, fetcher_url.path());
-  EXPECT_TRUE(base::StartsWith(fetcher_url.query(), "key",
+  auto* pending_request = GetPendingRequest();
+  DCHECK(pending_request);
+  GURL request_url = pending_request->request.url;
+  EXPECT_TRUE(request_url.SchemeIs(url::kHttpsScheme));
+  EXPECT_EQ(kServerPathForTestOperation, request_url.path());
+  EXPECT_TRUE(base::StartsWith(request_url.query(), "key",
                                base::CompareCase::SENSITIVE));
 
-  net::HttpRequestHeaders headers;
-  fetcher->GetExtraRequestHeaders(&headers);
+  net::HttpRequestHeaders headers = pending_request->request.headers;
   std::string content_type_header;
   headers.GetHeader(net::HttpRequestHeaders::kContentType,
                     &content_type_header);
   EXPECT_EQ("application/x-protobuf", content_type_header);
 
   // Experiment header should not be set.
-  EXPECT_EQ("", GetExperiementHeaderValue(fetcher));
+  EXPECT_EQ("", GetExperiementHeaderValue(pending_request));
 
-  EXPECT_TRUE(fetcher->upload_content_type().empty());
-  EXPECT_TRUE(fetcher->upload_data().empty());
+  std::string upload_content_type;
+  pending_request->request.headers.GetHeader(
+      net::HttpRequestHeaders::kContentType, &upload_content_type);
+  EXPECT_FALSE(upload_content_type.empty());
+  EXPECT_TRUE(network::GetUploadData(pending_request->request).empty());
 }
 
 TEST_F(GetOperationRequestTest, ExperimentHeaderInRequestData) {
@@ -76,11 +80,12 @@ TEST_F(GetOperationRequestTest, ExperimentHeaderInRequestData) {
 
   base::MockCallback<PrefetchRequestFinishedCallback> callback;
   std::unique_ptr<GetOperationRequest> request(CreateRequest(callback.Get()));
-  net::TestURLFetcher* fetcher = GetRunningFetcher();
+  auto* pending_request = GetPendingRequest();
+  DCHECK(pending_request);
 
   // Experiment header should be set.
   EXPECT_EQ(kExperimentValueSetInFieldTrial,
-            GetExperiementHeaderValue(fetcher));
+            GetExperiementHeaderValue(pending_request));
 }
 
 TEST_F(GetOperationRequestTest, EmptyResponse) {
@@ -94,6 +99,7 @@ TEST_F(GetOperationRequestTest, EmptyResponse) {
       .WillOnce(DoAll(SaveArg<0>(&status), SaveArg<1>(&operation_name),
                       SaveArg<2>(&pages)));
   RespondWithData("");
+  RunUntilIdle();
 
   EXPECT_EQ(PrefetchRequestStatus::SHOULD_RETRY_WITH_BACKOFF, status);
   EXPECT_EQ(std::string(kTestOperationName), operation_name);
@@ -111,6 +117,7 @@ TEST_F(GetOperationRequestTest, InvalidResponse) {
       .WillOnce(DoAll(SaveArg<0>(&status), SaveArg<1>(&operation_name),
                       SaveArg<2>(&pages)));
   RespondWithData("Some invalid data");
+  RunUntilIdle();
 
   EXPECT_EQ(PrefetchRequestStatus::SHOULD_RETRY_WITH_BACKOFF, status);
   EXPECT_EQ(std::string(kTestOperationName), operation_name);

components/offline_pages/core/prefetch/get_operation_task_unittest.cc

@@ -53,8 +53,7 @@ TEST_F(GetOperationTaskTest, NormalOperationTask) {
 
   EXPECT_NE(nullptr, prefetch_request_factory()->FindGetOperationRequestByName(
                          kOperationName));
-  std::string path =
-      url_fetcher_factory()->GetFetcherByID(0)->GetOriginalURL().path();
+  std::string path = GetPendingRequest(0 /*index*/)->request.url.path();
   EXPECT_THAT(path, HasSubstr(kOperationName));
   EXPECT_EQ(1, store_util()->LastCommandChangeCount());
   ASSERT_NE(nullptr, store_util()->GetPrefetchItem(id));

components/offline_pages/core/prefetch/prefetch_dispatcher_impl_unittest.cc

@@ -115,6 +115,10 @@ class TestPrefetchConfiguration : public PrefetchConfiguration {
 class FakePrefetchNetworkRequestFactory
     : public TestPrefetchNetworkRequestFactory {
  public:
+  FakePrefetchNetworkRequestFactory(
+      scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory)
+      : TestPrefetchNetworkRequestFactory(url_loader_factory) {}
+
   void MakeGeneratePageBundleRequest(
       const std::vector<std::string>& prefetch_urls,
       const std::string& gcm_registration_id,
@@ -254,7 +258,8 @@ void PrefetchDispatcherTest::SetUp() {
   ASSERT_TRUE(archive_directory_.CreateUniqueTempDir());
 
   dispatcher_ = new PrefetchDispatcherImpl();
-  network_request_factory_ = new FakePrefetchNetworkRequestFactory();
+  network_request_factory_ =
+      new FakePrefetchNetworkRequestFactory(shared_url_loader_factory());
   taco_.reset(new PrefetchServiceTestTaco);
   store_util_.BuildStore();
   taco_->SetPrefetchStore(store_util_.ReleaseStore());
@@ -544,7 +549,7 @@ TEST_F(PrefetchDispatcherTest, NoNetworkRequestsAfterNewURLs) {
   RunUntilIdle();
 
   // We should not have started GPB
-  EXPECT_EQ(nullptr, GetRunningFetcher());
+  EXPECT_EQ(nullptr, GetPendingRequest());
 }
 
 TEST_F(PrefetchDispatcherTest, ThumbnailFetchFailure_ItemDownloaded) {

components/offline_pages/core/prefetch/prefetch_gcm_app_handler_unittest.cc

@@ -7,8 +7,8 @@
 #include <utility>
 
 #include "base/bind.h"
+#include "base/message_loop/message_loop.h"
 #include "base/test/test_simple_task_runner.h"
-#include "base/threading/thread_task_runner_handle.h"
 #include "components/gcm_driver/instance_id/instance_id.h"
 #include "components/offline_pages/core/prefetch/prefetch_service_test_taco.h"
 #include "components/offline_pages/core/prefetch/test_prefetch_dispatcher.h"
@@ -35,9 +35,9 @@ class TestTokenFactory : public PrefetchGCMAppHandler::TokenFactory {
 
 class PrefetchGCMAppHandlerTest : public testing::Test {
  public:
-  PrefetchGCMAppHandlerTest()
-      : task_runner_(new base::TestSimpleTaskRunner),
-        task_runner_handle_(task_runner_) {}
+  PrefetchGCMAppHandlerTest() : task_runner_(new base::TestSimpleTaskRunner) {
+    message_loop_.SetTaskRunner(task_runner_);
+  }
 
   void SetUp() override {
     auto dispatcher = std::make_unique<TestPrefetchDispatcher>();
@@ -67,8 +67,8 @@ class PrefetchGCMAppHandlerTest : public testing::Test {
   TestTokenFactory* token_factory() { return token_factory_; }
 
  private:
+  base::MessageLoop message_loop_;
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
-  base::ThreadTaskRunnerHandle task_runner_handle_;
   std::unique_ptr<PrefetchServiceTestTaco> prefetch_service_taco_;
 
   // Owned by the taco.

components/offline_pages/core/prefetch/prefetch_network_request_factory_impl.cc

@@ -9,6 +9,7 @@
 #include "components/offline_pages/core/offline_page_feature.h"
 #include "components/offline_pages/core/prefetch/generate_page_bundle_request.h"
 #include "components/offline_pages/core/prefetch/get_operation_request.h"
+#include "services/network/public/cpp/shared_url_loader_factory.h"
 
 namespace {
 // Max size of all articles archives to be generated from a single request. This
@@ -42,10 +43,10 @@ void RecordGeneratePageBundleStatusUma(PrefetchRequestStatus status) {
 }
 
 PrefetchNetworkRequestFactoryImpl::PrefetchNetworkRequestFactoryImpl(
-    net::URLRequestContextGetter* request_context,
+    scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
     version_info::Channel channel,
     const std::string& user_agent)
-    : request_context_(request_context),
+    : url_loader_factory_(std::move(url_loader_factory)),
       channel_(channel),
       user_agent_(user_agent),
       weak_factory_(this) {}
@@ -71,7 +72,7 @@ void PrefetchNetworkRequestFactoryImpl::MakeGeneratePageBundleRequest(
   generate_page_bundle_requests_[request_id] =
       std::make_unique<GeneratePageBundleRequest>(
           user_agent_, gcm_registration_id, max_bundle_size, url_strings,
-          channel_, request_context_.get(),
+          channel_, url_loader_factory_,
           base::BindOnce(
               &PrefetchNetworkRequestFactoryImpl::GeneratePageBundleRequestDone,
               weak_factory_.GetWeakPtr(), std::move(callback), request_id));
@@ -94,7 +95,7 @@ void PrefetchNetworkRequestFactoryImpl::MakeGetOperationRequest(
     return;
   get_operation_requests_[operation_name] =
       std::make_unique<GetOperationRequest>(
-          operation_name, channel_, request_context_.get(),
+          operation_name, channel_, url_loader_factory_,
           base::BindOnce(
               &PrefetchNetworkRequestFactoryImpl::GetOperationRequestDone,
               weak_factory_.GetWeakPtr(), std::move(callback)));

components/offline_pages/core/prefetch/prefetch_network_request_factory_impl.h

@@ -14,7 +14,10 @@
 #include "components/offline_pages/core/prefetch/prefetch_dispatcher.h"
 #include "components/offline_pages/core/prefetch/prefetch_network_request_factory.h"
 #include "components/version_info/channel.h"
-#include "net/url_request/url_request_context_getter.h"
+
+namespace network {
+class SharedURLLoaderFactory;
+}
 
 namespace offline_pages {
 class GeneratePageBundleRequest;
@@ -23,7 +26,7 @@ class GetOperationRequest;
 class PrefetchNetworkRequestFactoryImpl : public PrefetchNetworkRequestFactory {
  public:
   PrefetchNetworkRequestFactoryImpl(
-      net::URLRequestContextGetter* request_context,
+      scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
       version_info::Channel channel,
       const std::string& user_agent);
 
@@ -70,7 +73,7 @@ class PrefetchNetworkRequestFactoryImpl : public PrefetchNetworkRequestFactory {
 
   uint64_t GetNextRequestId();
 
-  scoped_refptr<net::URLRequestContextGetter> request_context_;
+  scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory_;
   version_info::Channel channel_;
   std::string user_agent_;
 

components/offline_pages/core/prefetch/prefetch_network_request_factory_impl_unittest.cc

@@ -12,7 +12,6 @@
 #include "components/offline_pages/core/prefetch/get_operation_request.h"
 #include "components/offline_pages/core/prefetch/prefetch_request_test_base.h"
 #include "components/version_info/channel.h"
-#include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gmock/include/gmock/gmock-matchers.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -34,14 +33,13 @@ class PrefetchNetworkRequestFactoryTest : public PrefetchRequestTestBase {
   }
 
  private:
-  scoped_refptr<net::TestURLRequestContextGetter> request_context_;
   std::unique_ptr<PrefetchNetworkRequestFactoryImpl> request_factory_;
 };
 
-PrefetchNetworkRequestFactoryTest::PrefetchNetworkRequestFactoryTest()
-    : request_context_(new net::TestURLRequestContextGetter(task_runner())) {
+PrefetchNetworkRequestFactoryTest::PrefetchNetworkRequestFactoryTest() {
   request_factory_ = std::make_unique<PrefetchNetworkRequestFactoryImpl>(
-      request_context_.get(), version_info::Channel::UNKNOWN, "a user agent");
+      shared_url_loader_factory(), version_info::Channel::UNKNOWN,
+      "a user agent");
 }
 
 TEST_F(PrefetchNetworkRequestFactoryTest, TestMakeGetOperationRequest) {
@@ -217,6 +215,7 @@ TEST_F(PrefetchNetworkRequestFactoryTest, GetOperationRequestDoneUMA) {
   // Have the test system callback into GetOperationRequestDone with an error
   // code that will cause the SHOULD_SUSPEND response.
   RespondWithHttpError(net::HTTP_NOT_IMPLEMENTED);
+  RunUntilIdle();
 
   // Check that operation names have been cleaned up.
   EXPECT_FALSE(request_factory()->HasOutstandingRequests());
@@ -248,6 +247,7 @@ TEST_F(PrefetchNetworkRequestFactoryTest, GeneratePageBundleRequestDoneUMA) {
   // Have the test framework call back into the GeneratePageBundleRequestDone
   // method with an error code that will produce SHOULD_RETRY_WITHOUT_BACKOFF.
   RespondWithNetError(net::ERR_NETWORK_CHANGED);
+  RunUntilIdle();
 
   // Make sure the operation data got cleaned up properly.
   EXPECT_FALSE(request_factory()->HasOutstandingRequests());

components/offline_pages/core/prefetch/prefetch_request_fetcher.cc

@@ -13,9 +13,8 @@
 #include "net/http/http_request_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/traffic_annotation/network_traffic_annotation.h"
-#include "net/url_request/url_fetcher.h"
-#include "net/url_request/url_request_context_getter.h"
-#include "net/url_request/url_request_status.h"
+#include "services/network/public/cpp/shared_url_loader_factory.h"
+#include "services/network/public/cpp/simple_url_loader.h"
 #include "url/gurl.h"
 
 namespace offline_pages {
@@ -31,29 +30,28 @@ const char kRequestContentType[] = "application/x-protobuf";
 // static
 std::unique_ptr<PrefetchRequestFetcher> PrefetchRequestFetcher::CreateForGet(
     const GURL& url,
-    net::URLRequestContextGetter* request_context_getter,
+    scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
     FinishedCallback callback) {
   return base::WrapUnique(new PrefetchRequestFetcher(
-      url, std::string(), request_context_getter, std::move(callback)));
+      url, std::string(), url_loader_factory, std::move(callback)));
 }
 
 // static
 std::unique_ptr<PrefetchRequestFetcher> PrefetchRequestFetcher::CreateForPost(
     const GURL& url,
     const std::string& message,
-    net::URLRequestContextGetter* request_context_getter,
+    scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
     FinishedCallback callback) {
   return base::WrapUnique(new PrefetchRequestFetcher(
-      url, message, request_context_getter, std::move(callback)));
+      url, message, url_loader_factory, std::move(callback)));
 }
 
 PrefetchRequestFetcher::PrefetchRequestFetcher(
     const GURL& url,
     const std::string& message,
-    net::URLRequestContextGetter* request_context_getter,
+    scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
     FinishedCallback callback)
-    : request_context_getter_(request_context_getter),
-      callback_(std::move(callback)) {
+    : url_loader_factory_(url_loader_factory), callback_(std::move(callback)) {
   net::NetworkTrafficAnnotationTag traffic_annotation =
       net::DefineNetworkTrafficAnnotation("offline_prefetch", R"(
         semantics {
@@ -75,33 +73,38 @@ PrefetchRequestFetcher::PrefetchRequestFetcher(
           policy_exception_justification:
             "Not implemented, considered not useful."
         })");
-  url_fetcher_ = net::URLFetcher::Create(
-      url, message.empty() ? net::URLFetcher::GET : net::URLFetcher::POST, this,
-      traffic_annotation);
-  url_fetcher_->SetRequestContext(request_context_getter_.get());
-  url_fetcher_->SetAutomaticallyRetryOn5xx(false);
-  url_fetcher_->SetAutomaticallyRetryOnNetworkChanges(0);
+  auto resource_request = std::make_unique<network::ResourceRequest>();
+  resource_request->url = url;
+  resource_request->method = message.empty() ? "GET" : "POST";
+  resource_request->load_flags =
+      net::LOAD_DO_NOT_SEND_COOKIES | net::LOAD_DO_NOT_SAVE_COOKIES;
+
   std::string experiment_header = PrefetchExperimentHeader();
   if (!experiment_header.empty())
-    url_fetcher_->AddExtraRequestHeader(experiment_header);
-  if (message.empty()) {
-    std::string content_type_header(net::HttpRequestHeaders::kContentType);
-    content_type_header += ": ";
-    content_type_header += kRequestContentType;
-    url_fetcher_->AddExtraRequestHeader(content_type_header);
-  } else {
-    url_fetcher_->SetUploadData(kRequestContentType, message);
-  }
-  url_fetcher_->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
-                             net::LOAD_DO_NOT_SAVE_COOKIES);
-  url_fetcher_->Start();
+    resource_request->headers.AddHeaderFromString(experiment_header);
+
+  if (message.empty())
+    resource_request->headers.SetHeader(net::HttpRequestHeaders::kContentType,
+                                        kRequestContentType);
+
+  url_loader_ = network::SimpleURLLoader::Create(std::move(resource_request),
+                                                 traffic_annotation);
+
+  if (!message.empty())
+    url_loader_->AttachStringForUpload(message, kRequestContentType);
+
+  url_loader_->DownloadToStringOfUnboundedSizeUntilCrashAndDie(
+      url_loader_factory_.get(),
+      base::BindOnce(&PrefetchRequestFetcher::OnURLLoadComplete,
+                     base::Unretained(this)));
 }
 
 PrefetchRequestFetcher::~PrefetchRequestFetcher() {}
 
-void PrefetchRequestFetcher::OnURLFetchComplete(const net::URLFetcher* source) {
+void PrefetchRequestFetcher::OnURLLoadComplete(
+    std::unique_ptr<std::string> response_body) {
   std::string data;
-  PrefetchRequestStatus status = ParseResponse(source, &data);
+  PrefetchRequestStatus status = ParseResponse(std::move(response_body), &data);
 
   // TODO(jianli): Report UMA.
 
@@ -109,30 +112,33 @@ void PrefetchRequestFetcher::OnURLFetchComplete(const net::URLFetcher* source) {
 }
 
 PrefetchRequestStatus PrefetchRequestFetcher::ParseResponse(
-    const net::URLFetcher* source,
+    std::unique_ptr<std::string> response_body,
     std::string* data) {
-  if (!source->GetStatus().is_success()) {
-    net::Error net_error = source->GetStatus().ToNetError();
-    DVLOG(1) << "Net error: " << net_error;
-    return (net_error == net::ERR_BLOCKED_BY_ADMINISTRATOR)
+  int response_code = -1;
+  if (url_loader_->ResponseInfo() && url_loader_->ResponseInfo()->headers)
+    response_code = url_loader_->ResponseInfo()->headers->response_code();
+
+  if ((response_code < 200 || response_code > 299) && response_code != -1) {
+    DVLOG(1) << "HTTP status: " << response_code;
+    return (response_code == net::HTTP_NOT_IMPLEMENTED)
                ? PrefetchRequestStatus::SHOULD_SUSPEND
-               : PrefetchRequestStatus::SHOULD_RETRY_WITHOUT_BACKOFF;
+               : PrefetchRequestStatus::SHOULD_RETRY_WITH_BACKOFF;
   }
 
-  net::HttpStatusCode response_status =
-      static_cast<net::HttpStatusCode>(source->GetResponseCode());
-  if (response_status != net::HTTP_OK) {
-    DVLOG(1) << "HTTP status: " << response_status;
-    return (response_status == net::HTTP_NOT_IMPLEMENTED)
+  if (!response_body) {
+    int net_error = url_loader_->NetError();
+    DVLOG(1) << "Net error: " << net_error;
+    return (net_error == net::ERR_BLOCKED_BY_ADMINISTRATOR)
                ? PrefetchRequestStatus::SHOULD_SUSPEND
-               : PrefetchRequestStatus::SHOULD_RETRY_WITH_BACKOFF;
+               : PrefetchRequestStatus::SHOULD_RETRY_WITHOUT_BACKOFF;
   }
 
-  if (!source->GetResponseAsString(data) || data->empty()) {
+  if (response_body->empty()) {
     DVLOG(1) << "Failed to get response or empty response";
     return PrefetchRequestStatus::SHOULD_RETRY_WITH_BACKOFF;
   }
 
+  *data = *response_body;
   return PrefetchRequestStatus::SUCCESS;
 }
 

components/offline_pages/core/prefetch/prefetch_request_fetcher.h

@@ -9,17 +9,17 @@
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "components/offline_pages/core/prefetch/prefetch_types.h"
-#include "net/url_request/url_fetcher_delegate.h"
 #include "url/gurl.h"
 
-namespace net {
-class URLRequestContextGetter;
-}
+namespace network {
+class SharedURLLoaderFactory;
+class SimpleURLLoader;
+}  // namespace network
 
 namespace offline_pages {
 
 // Asynchronously fetches the offline prefetch related data from the server.
-class PrefetchRequestFetcher : public net::URLFetcherDelegate {
+class PrefetchRequestFetcher {
  public:
   using FinishedCallback = base::OnceCallback<void(PrefetchRequestStatus status,
                                                    const std::string& data)>;
@@ -27,34 +27,35 @@ class PrefetchRequestFetcher : public net::URLFetcherDelegate {
   // Creates a fetcher that will sends a GET request to the server.
   static std::unique_ptr<PrefetchRequestFetcher> CreateForGet(
       const GURL& url,
-      net::URLRequestContextGetter* request_context_getter,
+      scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
       FinishedCallback callback);
 
   // Creates a fetcher that will sends a POST request to the server.
   static std::unique_ptr<PrefetchRequestFetcher> CreateForPost(
       const GURL& url,
       const std::string& message,
-      net::URLRequestContextGetter* request_context_getter,
+      scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
       FinishedCallback callback);
 
-  ~PrefetchRequestFetcher() override;
+  ~PrefetchRequestFetcher();
 
-  // URLFetcherDelegate implementation.
-  void OnURLFetchComplete(const net::URLFetcher* source) override;
+  void OnURLLoadComplete(std::unique_ptr<std::string> response_body);
 
  private:
   // If |message| is empty, the GET request is sent. Otherwise, the POST request
   // is sent with |message| as post data.
-  PrefetchRequestFetcher(const GURL& url,
-                         const std::string& message,
-                         net::URLRequestContextGetter* request_context_getter,
-                         FinishedCallback callback);
+  PrefetchRequestFetcher(
+      const GURL& url,
+      const std::string& message,
+      scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
+      FinishedCallback callback);
 
-  PrefetchRequestStatus ParseResponse(const net::URLFetcher* source,
-                                      std::string* data);
+  PrefetchRequestStatus ParseResponse(
+      std::unique_ptr<std::string> response_body,
+      std::string* data);
 
-  scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
-  std::unique_ptr<net::URLFetcher> url_fetcher_;
+  scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory_;
+  std::unique_ptr<network::SimpleURLLoader> url_loader_;
   FinishedCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(PrefetchRequestFetcher);

components/offline_pages/core/prefetch/prefetch_request_fetcher_unittest.cc

@@ -27,7 +27,7 @@ const char kTestMessage[] = "Testing";
 class PrefetchRequestFetcherTest : public PrefetchRequestTestBase {
  public:
   PrefetchRequestStatus RunFetcherWithNetError(net::Error net_error);
-  PrefetchRequestStatus RunFetcherWithHttpError(int http_error);
+  PrefetchRequestStatus RunFetcherWithHttpError(net::HttpStatusCode http_error);
   PrefetchRequestStatus RunFetcherWithData(const std::string& response_data,
                                            std::string* data_received);
 
@@ -49,7 +49,7 @@ PrefetchRequestStatus PrefetchRequestFetcherTest::RunFetcherWithNetError(
 }
 
 PrefetchRequestStatus PrefetchRequestFetcherTest::RunFetcherWithHttpError(
-    int http_error) {
+    net::HttpStatusCode http_error) {
   std::string data_received;
   PrefetchRequestStatus status =
       RunFetcher(base::BindOnce(&PrefetchRequestTestBase::RespondWithHttpError,
@@ -72,14 +72,15 @@ PrefetchRequestStatus PrefetchRequestFetcherTest::RunFetcher(
     std::string* data_received) {
   base::MockCallback<PrefetchRequestFetcher::FinishedCallback> callback;
   std::unique_ptr<PrefetchRequestFetcher> fetcher =
-      PrefetchRequestFetcher::CreateForPost(kTestURL, kTestMessage,
-                                            request_context(), callback.Get());
+      PrefetchRequestFetcher::CreateForPost(
+          kTestURL, kTestMessage, shared_url_loader_factory(), callback.Get());
 
   PrefetchRequestStatus status;
   std::string data;
   EXPECT_CALL(callback, Run(_, _))
       .WillOnce(DoAll(SaveArg<0>(&status), SaveArg<1>(&data)));
   std::move(respond_callback).Run();
+  RunUntilIdle();
 
   *data_received = data;
   return status;

components/offline_pages/core/prefetch/prefetch_request_operation_response_unittest.cc

@@ -44,18 +44,19 @@ class RequestBuilder {
   virtual ~RequestBuilder() {}
 
   virtual void CreateRequest(
-      net::URLRequestContextGetter* request_context_getter,
+      scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
       PrefetchRequestFinishedCallback callback) = 0;
 };
 
 class GeneratePageBundleRequestBuilder : public RequestBuilder {
  public:
-  void CreateRequest(net::URLRequestContextGetter* request_context_getter,
-                     PrefetchRequestFinishedCallback callback) override {
+  void CreateRequest(
+      scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
+      PrefetchRequestFinishedCallback callback) override {
     std::vector<std::string> pages = {kTestURL, kTestURL2};
     fetcher_.reset(new GeneratePageBundleRequest(
         kTestUserAgent, kTestGCMID, kTestMaxBundleSize, pages, kTestChannel,
-        request_context_getter, std::move(callback)));
+        url_loader_factory, std::move(callback)));
   }
 
  private:
@@ -64,10 +65,11 @@ class GeneratePageBundleRequestBuilder : public RequestBuilder {
 
 class GetOperationRequestBuilder : public RequestBuilder {
  public:
-  void CreateRequest(net::URLRequestContextGetter* request_context_getter,
-                     PrefetchRequestFinishedCallback callback) override {
+  void CreateRequest(
+      scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
+      PrefetchRequestFinishedCallback callback) override {
     fetcher_.reset(new GetOperationRequest(kTestOperationName, kTestChannel,
-                                           request_context_getter,
+                                           url_loader_factory,
                                            std::move(callback)));
   }
 
@@ -159,10 +161,10 @@ class PrefetchRequestOperationResponseTestBuilder {
   PrefetchRequestOperationResponseTestBuilder() {}
   virtual ~PrefetchRequestOperationResponseTestBuilder() {}
 
-  void CreateRequest(net::URLRequestContextGetter* request_context_getter,
-                     PrefetchRequestFinishedCallback callback) {
-    request_builder_->CreateRequest(request_context_getter,
-                                    std::move(callback));
+  void CreateRequest(
+      scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
+      PrefetchRequestFinishedCallback callback) {
+    request_builder_->CreateRequest(url_loader_factory, std::move(callback));
   }
 
   std::string BuildFromAny(const std::string& any_type_url,
@@ -254,7 +256,7 @@ class PrefetchRequestOperationResponseTest : public PrefetchRequestTestBase {
  private:
   PrefetchRequestStatus SendWithResponse(const std::string& response_data) {
     base::MockCallback<PrefetchRequestFinishedCallback> callback;
-    builder_.CreateRequest(request_context(), callback.Get());
+    builder_.CreateRequest(shared_url_loader_factory(), callback.Get());
 
     PrefetchRequestStatus status;
     operation_name_.clear();
@@ -263,6 +265,7 @@ class PrefetchRequestOperationResponseTest : public PrefetchRequestTestBase {
         .WillOnce(DoAll(SaveArg<0>(&status), SaveArg<1>(&operation_name_),
                         SaveArg<2>(&pages_)));
     RespondWithData(response_data);
+    RunUntilIdle();
     return status;
   }
 

components/offline_pages/core/prefetch/prefetch_request_test_base.cc

@@ -8,11 +8,12 @@
 
 #include "base/feature_list.h"
 #include "base/metrics/field_trial_params.h"
+#include "base/test/bind_test_util.h"
 #include "base/test/mock_entropy_provider.h"
-#include "base/threading/thread_task_runner_handle.h"
 #include "components/offline_pages/core/offline_page_feature.h"
 #include "components/offline_pages/core/prefetch/prefetch_server_urls.h"
 #include "net/url_request/url_fetcher_delegate.h"
+#include "services/network/test/test_utils.h"
 
 namespace offline_pages {
 
@@ -21,15 +22,22 @@ const char PrefetchRequestTestBase::kExperimentValueSetInFieldTrial[] =
 
 PrefetchRequestTestBase::PrefetchRequestTestBase()
     : task_runner_(new base::TestMockTimeTaskRunner),
-      task_runner_handle_(task_runner_),
-      request_context_(new net::TestURLRequestContextGetter(
-          base::ThreadTaskRunnerHandle::Get())) {}
+      test_shared_url_loader_factory_(
+          base::MakeRefCounted<network::WeakWrapperSharedURLLoaderFactory>(
+              &test_url_loader_factory_)) {
+  message_loop_.SetTaskRunner(task_runner_);
+}
 
 PrefetchRequestTestBase::~PrefetchRequestTestBase() {}
 
 void PrefetchRequestTestBase::SetUp() {
   field_trial_list_ = std::make_unique<base::FieldTrialList>(
       std::make_unique<base::MockEntropyProvider>());
+
+  test_url_loader_factory_.SetInterceptor(
+      base::BindLambdaForTesting([&](const network::ResourceRequest& request) {
+        last_resource_request_ = request;
+      }));
 }
 
 void PrefetchRequestTestBase::SetUpExperimentOption() {
@@ -53,40 +61,46 @@ void PrefetchRequestTestBase::SetUpExperimentOption() {
 }
 
 void PrefetchRequestTestBase::RespondWithNetError(int net_error) {
-  net::TestURLFetcher* url_fetcher = GetRunningFetcher();
-  DCHECK(url_fetcher);
-  url_fetcher->set_status(net::URLRequestStatus::FromError(net_error));
-  url_fetcher->SetResponseString("");
-  url_fetcher->delegate()->OnURLFetchComplete(url_fetcher);
+  int pending_requests_count = test_url_loader_factory_.NumPending();
+  DCHECK(pending_requests_count > 0);
+  network::URLLoaderCompletionStatus completion_status(net_error);
+  test_url_loader_factory_.SimulateResponseForPendingRequest(
+      GetPendingRequest(0)->request.url, completion_status,
+      network::ResourceResponseHead(), std::string());
 }
 
-void PrefetchRequestTestBase::RespondWithHttpError(int http_error) {
-  net::TestURLFetcher* url_fetcher = GetRunningFetcher();
-  DCHECK(url_fetcher);
-  url_fetcher->set_status(net::URLRequestStatus());
-  url_fetcher->set_response_code(http_error);
-  url_fetcher->SetResponseString("");
-  url_fetcher->delegate()->OnURLFetchComplete(url_fetcher);
+void PrefetchRequestTestBase::RespondWithHttpError(
+    net::HttpStatusCode http_error) {
+  int pending_requests_count = test_url_loader_factory_.NumPending();
+  auto resource_response_head = network::CreateResourceResponseHead(http_error);
+  DCHECK(pending_requests_count > 0);
+  test_url_loader_factory_.SimulateResponseForPendingRequest(
+      GetPendingRequest(0)->request.url,
+      network::URLLoaderCompletionStatus(net::OK), resource_response_head,
+      std::string());
 }
 
 void PrefetchRequestTestBase::RespondWithData(const std::string& data) {
-  net::TestURLFetcher* url_fetcher = GetRunningFetcher();
-  DCHECK(url_fetcher);
-  url_fetcher->set_status(net::URLRequestStatus());
-  url_fetcher->set_response_code(net::HTTP_OK);
-  url_fetcher->SetResponseString(data);
-  url_fetcher->delegate()->OnURLFetchComplete(url_fetcher);
+  DCHECK(test_url_loader_factory_.pending_requests()->size() > 0);
+  test_url_loader_factory_.SimulateResponseForPendingRequest(
+      GetPendingRequest(0)->request.url.spec(), data);
 }
 
-net::TestURLFetcher* PrefetchRequestTestBase::GetRunningFetcher() {
-  // All created TestURLFetchers have ID 0 by default.
-  return url_fetcher_factory_.GetFetcherByID(0);
+network::TestURLLoaderFactory::PendingRequest*
+PrefetchRequestTestBase::GetPendingRequest(size_t index) {
+  if (index >= test_url_loader_factory_.pending_requests()->size())
+    return nullptr;
+  network::TestURLLoaderFactory::PendingRequest* request =
+      &(*test_url_loader_factory_.pending_requests())[index];
+  DCHECK(request);
+  return request;
 }
 
 std::string PrefetchRequestTestBase::GetExperiementHeaderValue(
-    net::TestURLFetcher* fetcher) {
-  net::HttpRequestHeaders headers;
-  fetcher->GetExtraRequestHeaders(&headers);
+    network::TestURLLoaderFactory::PendingRequest* pending_request) {
+  DCHECK(pending_request);
+
+  net::HttpRequestHeaders headers = pending_request->request.headers;
 
   std::string experiment_header;
   headers.GetHeader(kPrefetchExperimentHeaderName, &experiment_header);

components/offline_pages/core/prefetch/prefetch_request_test_base.h

@@ -6,12 +6,12 @@
 #define COMPONENTS_OFFLINE_PAGES_CORE_PREFETCH_PREFETCH_REQUEST_FETCHER_TEST_BASE_H_
 
 #include "base/memory/ref_counted.h"
+#include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/test/scoped_feature_list.h"
 #include "base/test/test_mock_time_task_runner.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "net/url_request/test_url_fetcher_factory.h"
-#include "net/url_request/url_request_test_util.h"
+#include "services/network/public/cpp/weak_wrapper_shared_url_loader_factory.h"
+#include "services/network/test/test_url_loader_factory.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace offline_pages {
@@ -29,13 +29,17 @@ class PrefetchRequestTestBase : public testing::Test {
   void SetUpExperimentOption();
 
   void RespondWithNetError(int net_error);
-  void RespondWithHttpError(int http_error);
+  void RespondWithHttpError(net::HttpStatusCode http_error);
   void RespondWithData(const std::string& data);
-  net::TestURLFetcher* GetRunningFetcher();
-  std::string GetExperiementHeaderValue(net::TestURLFetcher* fetcher);
+  network::TestURLLoaderFactory::PendingRequest* GetPendingRequest(
+      size_t index = 0);
 
-  net::URLRequestContextGetter* request_context() const {
-    return request_context_.get();
+  std::string GetExperiementHeaderValue(
+      network::TestURLLoaderFactory::PendingRequest* pending_request);
+
+  scoped_refptr<network::SharedURLLoaderFactory> shared_url_loader_factory()
+      const {
+    return test_shared_url_loader_factory_;
   }
 
   void RunUntilIdle();
@@ -48,10 +52,14 @@ class PrefetchRequestTestBase : public testing::Test {
   }
 
  private:
+  base::MessageLoopForIO message_loop_;
   scoped_refptr<base::TestMockTimeTaskRunner> task_runner_;
-  base::ThreadTaskRunnerHandle task_runner_handle_;
-  net::TestURLFetcherFactory url_fetcher_factory_;
-  scoped_refptr<net::TestURLRequestContextGetter> request_context_;
+
+  network::TestURLLoaderFactory test_url_loader_factory_;
+  scoped_refptr<network::SharedURLLoaderFactory>
+      test_shared_url_loader_factory_;
+  network::ResourceRequest last_resource_request_;
+
   std::unique_ptr<base::FieldTrialList> field_trial_list_;
   base::test::ScopedFeatureList scoped_feature_list_;
 };

components/offline_pages/core/prefetch/prefetch_task_test_base.cc

@@ -16,7 +16,11 @@ constexpr std::array<PrefetchItemState, 11>
     PrefetchTaskTestBase::kOrderedPrefetchItemStates;
 
 PrefetchTaskTestBase::PrefetchTaskTestBase()
-    : store_test_util_(task_runner()) {}
+    : test_shared_url_loader_factory_(
+          base::MakeRefCounted<network::WeakWrapperSharedURLLoaderFactory>(
+              &test_url_loader_factory_)),
+      prefetch_request_factory_(test_shared_url_loader_factory_),
+      store_test_util_(task_runner()) {}
 
 PrefetchTaskTestBase::~PrefetchTaskTestBase() = default;
 
@@ -68,4 +72,13 @@ std::set<PrefetchItem> PrefetchTaskTestBase::FilterByState(
   return result;
 }
 
+network::TestURLLoaderFactory::PendingRequest*
+PrefetchTaskTestBase::GetPendingRequest(size_t index) {
+  if (index >= test_url_loader_factory_.pending_requests()->size())
+    return nullptr;
+  auto* request = &(*test_url_loader_factory_.pending_requests())[index];
+  DCHECK(request);
+  return request;
+}
+
 }  // namespace offline_pages

components/offline_pages/core/prefetch/prefetch_task_test_base.h

@@ -13,7 +13,8 @@
 #include "components/offline_pages/core/prefetch/store/prefetch_store_test_util.h"
 #include "components/offline_pages/core/prefetch/test_prefetch_network_request_factory.h"
 #include "components/offline_pages/task/task_test_base.h"
-#include "net/url_request/test_url_fetcher_factory.h"
+#include "services/network/public/cpp/weak_wrapper_shared_url_loader_factory.h"
+#include "services/network/test/test_url_loader_factory.h"
 
 namespace offline_pages {
 struct PrefetchItem;
@@ -53,14 +54,13 @@ class PrefetchTaskTestBase : public TaskTestBase {
       const std::set<PrefetchItem>& items,
       PrefetchItemState state);
 
+  network::TestURLLoaderFactory::PendingRequest* GetPendingRequest(
+      size_t index = 0);
+
   TestPrefetchNetworkRequestFactory* prefetch_request_factory() {
     return &prefetch_request_factory_;
   }
 
-  net::TestURLFetcherFactory* url_fetcher_factory() {
-    return &url_fetcher_factory_;
-  }
-
   PrefetchStore* store() { return store_test_util_.store(); }
 
   PrefetchStoreTestUtil* store_util() { return &store_test_util_; }
@@ -68,7 +68,9 @@ class PrefetchTaskTestBase : public TaskTestBase {
   MockPrefetchItemGenerator* item_generator() { return &item_generator_; }
 
  private:
-  net::TestURLFetcherFactory url_fetcher_factory_;
+  network::TestURLLoaderFactory test_url_loader_factory_;
+  scoped_refptr<network::SharedURLLoaderFactory>
+      test_shared_url_loader_factory_;
   TestPrefetchNetworkRequestFactory prefetch_request_factory_;
   PrefetchStoreTestUtil store_test_util_;
   MockPrefetchItemGenerator item_generator_;

components/offline_pages/core/prefetch/suggested_articles_observer_unittest.cc

@@ -5,10 +5,10 @@
 #include "components/offline_pages/core/prefetch/suggested_articles_observer.h"
 
 #include "base/memory/ptr_util.h"
+#include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/test_simple_task_runner.h"
-#include "base/threading/thread_task_runner_handle.h"
 #include "components/offline_pages/core/client_namespace_constants.h"
 #include "components/offline_pages/core/prefetch/prefetch_dispatcher.h"
 #include "components/offline_pages/core/prefetch/prefetch_gcm_app_handler.h"
@@ -42,8 +42,9 @@ ContentSuggestion ContentSuggestionFromTestURL(const GURL& test_url) {
 class OfflinePageSuggestedArticlesObserverTest : public testing::Test {
  public:
   OfflinePageSuggestedArticlesObserverTest()
-      : task_runner_(new base::TestSimpleTaskRunner),
-        task_runner_handle_(task_runner_) {}
+      : task_runner_(new base::TestSimpleTaskRunner) {
+    message_loop_.SetTaskRunner(task_runner_);
+  }
 
   void SetUp() override {
     prefetch_service_test_taco_ = std::make_unique<PrefetchServiceTestTaco>();
@@ -75,8 +76,8 @@ class OfflinePageSuggestedArticlesObserverTest : public testing::Test {
       Category::FromKnownCategory(ntp_snippets::KnownCategories::ARTICLES);
 
  private:
+  base::MessageLoop message_loop_;
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
-  base::ThreadTaskRunnerHandle task_runner_handle_;
   std::unique_ptr<PrefetchServiceTestTaco> prefetch_service_test_taco_;
 
   // Owned by the PrefetchServiceTestTaco.

components/offline_pages/core/prefetch/test_prefetch_network_request_factory.cc

@@ -9,6 +9,7 @@
 
 #include "components/offline_pages/core/prefetch/generate_page_bundle_request.h"
 #include "components/offline_pages/core/prefetch/get_operation_request.h"
+#include "services/network/test/test_shared_url_loader_factory.h"
 
 namespace offline_pages {
 namespace {
@@ -17,15 +18,13 @@ const char kUserAgent[] = "Chrome/57.0.2987.133";
 }  // namespace
 
 TestPrefetchNetworkRequestFactory::TestPrefetchNetworkRequestFactory()
-    : TestPrefetchNetworkRequestFactory(new net::TestURLRequestContextGetter(
-          base::ThreadTaskRunnerHandle::Get())) {}
+    : TestPrefetchNetworkRequestFactory(
+          new network::TestSharedURLLoaderFactory) {}
 
 TestPrefetchNetworkRequestFactory::TestPrefetchNetworkRequestFactory(
-    net::TestURLRequestContextGetter* request_context_getter)
-    : PrefetchNetworkRequestFactoryImpl(request_context_getter,
-                                        kChannel,
-                                        kUserAgent) {
-  request_context = request_context_getter;
+    scoped_refptr<network::SharedURLLoaderFactory> loader)
+    : PrefetchNetworkRequestFactoryImpl(loader, kChannel, kUserAgent) {
+  url_loader_factory = loader;
 }
 
 TestPrefetchNetworkRequestFactory::~TestPrefetchNetworkRequestFactory() =

components/offline_pages/core/prefetch/test_prefetch_network_request_factory.h

@@ -13,7 +13,6 @@
 #include "components/offline_pages/core/prefetch/prefetch_network_request_factory_impl.h"
 #include "components/offline_pages/core/prefetch/prefetch_types.h"
 #include "components/version_info/channel.h"
-#include "net/url_request/url_request_test_util.h"
 
 namespace offline_pages {
 
@@ -24,10 +23,10 @@ class TestPrefetchNetworkRequestFactory
  public:
   TestPrefetchNetworkRequestFactory();
   explicit TestPrefetchNetworkRequestFactory(
-      net::TestURLRequestContextGetter* request_context);
+      scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory);
   ~TestPrefetchNetworkRequestFactory() override;
 
-  scoped_refptr<net::TestURLRequestContextGetter> request_context;
+  scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory;
 };
 
 }  // namespace offline_pages

components/offline_pages/task/task_test_base.cc

@@ -5,7 +5,6 @@
 #include "components/offline_pages/task/task_test_base.h"
 
 #include "base/test/mock_callback.h"
-#include "base/threading/thread_task_runner_handle.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using testing::_;
@@ -14,8 +13,9 @@ namespace offline_pages {
 
 TaskTestBase::TaskTestBase()
     : task_runner_(new base::TestMockTimeTaskRunner),
-      task_runner_handle_(task_runner_),
-      test_task_runner_(task_runner_) {}
+      test_task_runner_(task_runner_) {
+  message_loop_.SetTaskRunner(task_runner_);
+}
 
 TaskTestBase::~TaskTestBase() = default;
 

components/offline_pages/task/task_test_base.h

@@ -7,8 +7,8 @@
 
 #include "testing/gtest/include/gtest/gtest.h"
 
+#include "base/message_loop/message_loop.h"
 #include "base/test/test_mock_time_task_runner.h"
-#include "base/threading/thread_task_runner_handle.h"
 #include "components/offline_pages/task/task.h"
 #include "components/offline_pages/task/test_task_runner.h"
 
@@ -36,8 +36,8 @@ class TaskTestBase : public testing::Test {
   }
 
  private:
+  base::MessageLoopForIO message_loop_;
   scoped_refptr<base::TestMockTimeTaskRunner> task_runner_;
-  base::ThreadTaskRunnerHandle task_runner_handle_;
   TestTaskRunner test_task_runner_;
 };