Migrate IntranetRedirectDetector to SimpleURLLoader

Bug: 773295
Change-Id: I5a1783b49d8e20119843af96919bc341d6612f6e
Reviewed-on: https://chromium-review.googlesource.com/986675
Commit-Queue: Mark Pilgrim <pilgrim@chromium.org>
Reviewed-by: Nico Weber <thakis@chromium.org>
Reviewed-by: Matt Menke <mmenke@chromium.org>
Cr-Commit-Position: refs/heads/master@{#547057}

chrome/browser/intranet_redirect_detector.cc

@@ -15,17 +15,20 @@
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/net/system_network_context_manager.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
+#include "content/public/browser/browser_context.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/storage_partition.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.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/resource_request.h"
+#include "services/network/public/cpp/simple_url_loader.h"
 
 IntranetRedirectDetector::IntranetRedirectDetector()
     : redirect_origin_(g_browser_process->local_state()->GetString(
@@ -69,14 +72,14 @@ void IntranetRedirectDetector::FinishSleep() {
   in_sleep_ = false;
 
   // If another fetch operation is still running, cancel it.
-  fetchers_.clear();
+  simple_loaders_.clear();
   resulting_origins_.clear();
 
   const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
   if (cmd_line->HasSwitch(switches::kDisableBackgroundNetworking))
     return;
 
-  DCHECK(fetchers_.empty() && resulting_origins_.empty());
+  DCHECK(simple_loaders_.empty() && resulting_origins_.empty());
 
   // Create traffic annotation tag.
   net::NetworkTrafficAnnotationTag traffic_annotation =
@@ -101,7 +104,7 @@ void IntranetRedirectDetector::FinishSleep() {
               "Not implemented, considered not useful."
         })");
 
-  // Start three fetchers on random hostnames.
+  // Start three loaders on random hostnames.
   for (size_t i = 0; i < 3; ++i) {
     std::string url_string("http://");
     // We generate a random hostname with between 7 and 15 characters.
@@ -109,41 +112,45 @@ void IntranetRedirectDetector::FinishSleep() {
     for (int j = 0; j < num_chars; ++j)
       url_string += ('a' + base::RandInt(0, 'z' - 'a'));
     GURL random_url(url_string + '/');
-    std::unique_ptr<net::URLFetcher> fetcher = net::URLFetcher::Create(
-        random_url, net::URLFetcher::HEAD, this, traffic_annotation);
+
+    auto resource_request = std::make_unique<network::ResourceRequest>();
+    resource_request->url = random_url;
+    resource_request->method = "HEAD";
     // We don't want these fetches to affect existing state in the profile.
-    fetcher->SetLoadFlags(net::LOAD_DISABLE_CACHE |
-                          net::LOAD_DO_NOT_SAVE_COOKIES |
-                          net::LOAD_DO_NOT_SEND_COOKIES |
-                          net::LOAD_DO_NOT_SEND_AUTH_DATA);
-    fetcher->SetRequestContext(g_browser_process->system_request_context());
-    fetcher->Start();
-    net::URLFetcher* fetcher_ptr = fetcher.get();
-    fetchers_[fetcher_ptr] = std::move(fetcher);
+    resource_request->load_flags =
+        net::LOAD_DISABLE_CACHE | net::LOAD_DO_NOT_SAVE_COOKIES |
+        net::LOAD_DO_NOT_SEND_COOKIES | net::LOAD_DO_NOT_SEND_AUTH_DATA;
+    network::mojom::URLLoaderFactory* loader_factory =
+        g_browser_process->system_network_context_manager()
+            ->GetURLLoaderFactory();
+    std::unique_ptr<network::SimpleURLLoader> simple_loader =
+        network::SimpleURLLoader::Create(std::move(resource_request),
+                                         traffic_annotation);
+    network::SimpleURLLoader* simple_loader_ptr = simple_loader.get();
+    simple_loader->DownloadToString(
+        loader_factory,
+        base::BindOnce(&IntranetRedirectDetector::OnSimpleLoaderComplete,
+                       base::Unretained(this), simple_loader_ptr),
+        /*max_body_size=*/1);
+    simple_loaders_[simple_loader_ptr] = std::move(simple_loader);
   }
 }
 
-void IntranetRedirectDetector::OnURLFetchComplete(
-    const net::URLFetcher* source) {
-  // Delete the fetcher on this function's exit.
-  auto it = fetchers_.find(const_cast<net::URLFetcher*>(source));
-  DCHECK(it != fetchers_.end());
-  std::unique_ptr<net::URLFetcher> fetcher = std::move(it->second);
-  fetchers_.erase(it);
-
-  // If any two fetches result in the same domain/host, we set the redirect
+void IntranetRedirectDetector::OnSimpleLoaderComplete(
+    network::SimpleURLLoader* source,
+    std::unique_ptr<std::string> response_body) {
+  // Delete the loader on this function's exit.
+  auto it = simple_loaders_.find(source);
+  DCHECK(it != simple_loaders_.end());
+  std::unique_ptr<network::SimpleURLLoader> simple_loader =
+      std::move(it->second);
+  simple_loaders_.erase(it);
+
+  // If any two loaders result in the same domain/host, we set the redirect
   // origin to that; otherwise we set it to nothing.
-  if (!source->GetStatus().is_success() || (source->GetResponseCode() != 200)) {
-    if ((resulting_origins_.empty()) ||
-        ((resulting_origins_.size() == 1) &&
-         resulting_origins_.front().is_valid())) {
-      resulting_origins_.push_back(GURL());
-      return;
-    }
-    redirect_origin_ = GURL();
-  } else {
-    DCHECK(source->GetURL().is_valid());
-    GURL origin(source->GetURL().GetOrigin());
+  if (response_body) {
+    DCHECK(source->GetFinalURL().is_valid());
+    GURL origin(source->GetFinalURL().GetOrigin());
     if (resulting_origins_.empty()) {
       resulting_origins_.push_back(origin);
       return;
@@ -153,10 +160,10 @@ void IntranetRedirectDetector::OnURLFetchComplete(
         origin,
         net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES)) {
       redirect_origin_ = origin;
-      if (!fetchers_.empty()) {
-        // Cancel remaining fetch, we don't need it.
-        DCHECK(fetchers_.size() == 1);
-        fetchers_.clear();
+      if (!simple_loaders_.empty()) {
+        // Cancel remaining loader, we don't need it.
+        DCHECK(simple_loaders_.size() == 1);
+        simple_loaders_.clear();
       }
     }
     if (resulting_origins_.size() == 1) {
@@ -170,6 +177,13 @@ void IntranetRedirectDetector::OnURLFetchComplete(
             origin,
             net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES);
     redirect_origin_ = same_domain_or_host ? origin : GURL();
+  } else {
+    if (resulting_origins_.empty() || (resulting_origins_.size() == 1 &&
+                                       resulting_origins_.front().is_valid())) {
+      resulting_origins_.push_back(GURL());
+      return;
+    }
+    redirect_origin_ = GURL();
   }
 
   g_browser_process->local_state()->SetString(

chrome/browser/intranet_redirect_detector.h

@@ -16,9 +16,12 @@
 #include "content/public/browser/notification_registrar.h"
 #include "net/base/network_change_notifier.h"
 #include "net/dns/host_resolver_proc.h"
-#include "net/url_request/url_fetcher_delegate.h"
 #include "url/gurl.h"
 
+namespace network {
+class SimpleURLLoader;
+}
+
 class PrefRegistrySimple;
 
 // This object is responsible for determining whether the user is on a network
@@ -38,8 +41,7 @@ class PrefRegistrySimple;
 // return a value at all times (even during startup or in unittest mode).  If no
 // redirection is in place, the returned GURL will be empty.
 class IntranetRedirectDetector
-    : public net::URLFetcherDelegate,
-      public net::NetworkChangeNotifier::NetworkChangeObserver {
+    : public net::NetworkChangeNotifier::NetworkChangeObserver {
  public:
   // Only the main browser process loop should call this, when setting up
   // g_browser_process->intranet_redirect_detector_.  No code other than the
@@ -61,15 +63,17 @@ class IntranetRedirectDetector
   // switch sleep has finished.  Runs any pending fetch.
   void FinishSleep();
 
-  // net::URLFetcherDelegate
-  void OnURLFetchComplete(const net::URLFetcher* source) override;
+  // Invoked from SimpleURLLoader after download is complete.
+  void OnSimpleLoaderComplete(network::SimpleURLLoader* source,
+                              std::unique_ptr<std::string> response_body);
 
   // NetworkChangeNotifier::NetworkChangeObserver
   void OnNetworkChanged(
       net::NetworkChangeNotifier::ConnectionType type) override;
 
   GURL redirect_origin_;
-  std::map<net::URLFetcher*, std::unique_ptr<net::URLFetcher>> fetchers_;
+  std::map<network::SimpleURLLoader*, std::unique_ptr<network::SimpleURLLoader>>
+      simple_loaders_;
   std::vector<GURL> resulting_origins_;
   bool in_sleep_;  // True if we're in the seven-second "no fetching" period
                    // that begins at browser start, or the one-second "no