Move FuzzedDataProvider to //base and expose to blink

net/dns/host_resolver_impl_fuzzer.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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <vector>
 
 #include "base/bind.h"
+#include "base/fuzzed_data_provider.h"
 #include "base/logging.h"
 #include "base/run_loop.h"
 #include "net/base/address_family.h"
 #include "net/base/address_list.h"
-#include "net/base/fuzzed_data_provider.h"
 #include "net/base/net_errors.h"
 #include "net/base/request_priority.h"
 #include "net/dns/fuzzed_host_resolver.h"
 #include "net/dns/host_resolver.h"
 #include "net/log/test_net_log.h"
 
 namespace {
 
 const char* kHostNames[] = {"foo", "foo.com",   "a.foo.com",
                             "bar", "localhost", "localhost6"};
 
 net::AddressFamily kAddressFamilies[] = {
     net::ADDRESS_FAMILY_UNSPECIFIED, net::ADDRESS_FAMILY_IPV4,
     net::ADDRESS_FAMILY_IPV6,
 };
 
 class DnsRequest {
  public:
   DnsRequest(net::HostResolver* host_resolver,
-             net::FuzzedDataProvider* data_provider,
+             base::FuzzedDataProvider* data_provider,
              std::vector<std::unique_ptr<DnsRequest>>* dns_requests)
       : host_resolver_(host_resolver),
         data_provider_(data_provider),
         dns_requests_(dns_requests),
         is_running_(false) {}
 
   ~DnsRequest() {}
 
   // Creates and starts a DNS request using fuzzed parameters. If the request
   // doesn't complete synchronously, adds it to |dns_requests|.
   static void CreateRequest(
       net::HostResolver* host_resolver,
-      net::FuzzedDataProvider* data_provider,
+      base::FuzzedDataProvider* data_provider,
       std::vector<std::unique_ptr<DnsRequest>>* dns_requests) {
     std::unique_ptr<DnsRequest> dns_request(
         new DnsRequest(host_resolver, data_provider, dns_requests));
 
     if (dns_request->Start() == net::ERR_IO_PENDING)
       dns_requests->push_back(std::move(dns_request));
   }
 
   // If |dns_requests| is non-empty, waits for a randomly chosen one of the
   // requests to complete and removes it from |dns_requests|.
   static void WaitForRequestComplete(
-      net::FuzzedDataProvider* data_provider,
+      base::FuzzedDataProvider* data_provider,
       std::vector<std::unique_ptr<DnsRequest>>* dns_requests) {
     if (dns_requests->empty())
       return;
     uint32_t index =
         data_provider->ConsumeUint32InRange(0, dns_requests->size() - 1);
 
     // Remove the request from the list before waiting on it - this prevents one
     // of the other callbacks from deleting the callback being waited on.
     std::unique_ptr<DnsRequest> request = std::move((*dns_requests)[index]);
     dns_requests->erase(dns_requests->begin() + index);
     request->WaitUntilDone();
   }
 
   // If |dns_requests| is non-empty, attempts to cancel a randomly chosen one of
   // them and removes it from |dns_requests|. If the one it picks is already
   // complete, just removes it from the list.
   static void CancelRequest(
       net::HostResolver* host_resolver,
-      net::FuzzedDataProvider* data_provider,
+      base::FuzzedDataProvider* data_provider,
       std::vector<std::unique_ptr<DnsRequest>>* dns_requests) {
     if (dns_requests->empty())
       return;
     uint32_t index =
         data_provider->ConsumeUint32InRange(0, dns_requests->size() - 1);
     auto request = dns_requests->begin() + index;
     (*request)->Cancel();
     dns_requests->erase(request);
   }
 
@@ skipping 76 matching lines @@
     }
   }
 
   // Cancel the request, if not already completed. Otherwise, does nothing.
   void Cancel() {
     request_.reset();
     is_running_ = false;
   }
 
   net::HostResolver* host_resolver_;
-  net::FuzzedDataProvider* data_provider_;
+  base::FuzzedDataProvider* data_provider_;
   std::vector<std::unique_ptr<DnsRequest>>* dns_requests_;
 
   std::unique_ptr<net::HostResolver::Request> request_;
   net::AddressList address_list_;
 
   bool is_running_;
 
   std::unique_ptr<base::RunLoop> run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(DnsRequest);
 };
 
 }  // namespace
 
 // Fuzzer for HostResolverImpl. Fuzzes using both the system resolver and
 // built-in DNS client paths.
 //
 // TODO(mmenke): Add coverage for things this does not cover:
 //     * Out of order completion, particularly for the platform resolver path.
 //     * Simulate network changes, including both enabling and disabling the
 //     async resolver while lookups are active as a result of the change.
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   {
-    net::FuzzedDataProvider data_provider(data, size);
+    base::FuzzedDataProvider data_provider(data, size);
     net::TestNetLog net_log;
 
     net::HostResolver::Options options;
     options.max_concurrent_resolves = data_provider.ConsumeUint32InRange(1, 8);
     options.enable_caching = data_provider.ConsumeBool();
     net::FuzzedHostResolver host_resolver(options, &net_log, &data_provider);
     host_resolver.SetDnsClientEnabled(data_provider.ConsumeBool());
 
     std::vector<std::unique_ptr<DnsRequest>> dns_requests;
     while (true) {
@@ skipping 14 matching lines @@
           break;
       }
     }
   }
 
   // Clean up any pending tasks, after deleting everything.
   base::RunLoop().RunUntilIdle();
 
   return 0;
 }