Move FuzzedDataProvider to //base and expose to blink

net/dns/fuzzed_host_resolver.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 "net/dns/fuzzed_host_resolver.h"
 
 #include <stdint.h>
 
 #include <limits>
 #include <string>
 
 #include "base/bind.h"
+#include "base/fuzzed_data_provider.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "net/base/address_list.h"
-#include "net/base/fuzzed_data_provider.h"
 #include "net/base/ip_address.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/dns/dns_client.h"
 #include "net/dns/dns_config_service.h"
 #include "net/dns/dns_hosts.h"
 
 namespace net {
 
 namespace {
 
 // Returns a fuzzed non-zero port number.
-uint16_t FuzzPort(FuzzedDataProvider* data_provider) {
+uint16_t FuzzPort(base::FuzzedDataProvider* data_provider) {
   return data_provider->ConsumeUint16();
 }
 
 // Returns a fuzzed IPv4 address.  Can return invalid / reserved addresses.
-IPAddress FuzzIPv4Address(FuzzedDataProvider* data_provider) {
+IPAddress FuzzIPv4Address(base::FuzzedDataProvider* data_provider) {
   return IPAddress(data_provider->ConsumeUint8(), data_provider->ConsumeUint8(),
                    data_provider->ConsumeUint8(),
                    data_provider->ConsumeUint8());
 }
 
 // Returns a fuzzed IPv6 address.  Can return invalid / reserved addresses.
-IPAddress FuzzIPv6Address(FuzzedDataProvider* data_provider) {
+IPAddress FuzzIPv6Address(base::FuzzedDataProvider* data_provider) {
   return IPAddress(data_provider->ConsumeUint8(), data_provider->ConsumeUint8(),
                    data_provider->ConsumeUint8(), data_provider->ConsumeUint8(),
                    data_provider->ConsumeUint8(), data_provider->ConsumeUint8(),
                    data_provider->ConsumeUint8(), data_provider->ConsumeUint8(),
                    data_provider->ConsumeUint8(), data_provider->ConsumeUint8(),
                    data_provider->ConsumeUint8(), data_provider->ConsumeUint8(),
                    data_provider->ConsumeUint8(), data_provider->ConsumeUint8(),
                    data_provider->ConsumeUint8(),
                    data_provider->ConsumeUint8());
 }
 
 // Returns a fuzzed address, which can be either IPv4 or IPv6.  Can return
 // invalid / reserved addresses.
-IPAddress FuzzIPAddress(FuzzedDataProvider* data_provider) {
+IPAddress FuzzIPAddress(base::FuzzedDataProvider* data_provider) {
   if (data_provider->ConsumeBool())
     return FuzzIPv4Address(data_provider);
   return FuzzIPv6Address(data_provider);
 }
 
 // HostResolverProc that returns a random set of results, and can succeed or
 // fail. Must only be run on the thread it's created on.
 class FuzzedHostResolverProc : public HostResolverProc {
  public:
   // Can safely be used after the destruction of |data_provider|. This can
   // happen if a request is issued but the code never waits for the result
   // before the test ends.
   explicit FuzzedHostResolverProc(
-      base::WeakPtr<FuzzedDataProvider> data_provider)
+      base::WeakPtr<base::FuzzedDataProvider> data_provider)
       : HostResolverProc(nullptr),
         data_provider_(data_provider),
         network_task_runner_(base::ThreadTaskRunnerHandle::Get()) {}
 
   int Resolve(const std::string& host,
               AddressFamily address_family,
               HostResolverFlags host_resolver_flags,
               AddressList* addrlist,
               int* os_error) override {
     DCHECK(network_task_runner_->BelongsToCurrentThread());
@@ skipping 37 matching lines @@
       result.set_canonical_name("foo.com");
     }
 
     *addrlist = result;
     return OK;
   }
 
  private:
   ~FuzzedHostResolverProc() override {}
 
-  base::WeakPtr<FuzzedDataProvider> data_provider_;
+  base::WeakPtr<base::FuzzedDataProvider> data_provider_;
 
   // Just used for thread-safety checks.
   scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(FuzzedHostResolverProc);
 };
 
 }  // namespace
 
 FuzzedHostResolver::FuzzedHostResolver(const Options& options,
                                        NetLog* net_log,
-                                       FuzzedDataProvider* data_provider)
+                                       base::FuzzedDataProvider* data_provider)
     : HostResolverImpl(options, net_log, base::ThreadTaskRunnerHandle::Get()),
       data_provider_(data_provider),
       socket_factory_(data_provider),
       is_ipv6_reachable_(data_provider->ConsumeBool()),
       net_log_(net_log),
       data_provider_weak_factory_(data_provider) {
   HostResolverImpl::ProcTaskParams proc_task_params(
       new FuzzedHostResolverProc(data_provider_weak_factory_.GetWeakPtr()),
       // Retries are only used when the original request hangs, which this class
       // currently can't simulate.
@@ skipping 57 matching lines @@
 
   config.rotate = data_provider_->ConsumeBool();
 
   // Doesn't currently seem to do anything.
   config.edns0 = false;
 
   config.use_local_ipv6 = data_provider_->ConsumeBool();
 
   std::unique_ptr<DnsClient> dns_client = DnsClient::CreateClientForTesting(
       net_log_, &socket_factory_,
-      base::Bind(&FuzzedDataProvider::ConsumeInt32InRange,
+      base::Bind(&base::FuzzedDataProvider::ConsumeInt32InRange,
                  base::Unretained(data_provider_)));
   dns_client->SetConfig(config);
   SetDnsClient(std::move(dns_client));
 }
 
 bool FuzzedHostResolver::IsIPv6Reachable(const BoundNetLog& net_log) {
   return is_ipv6_reachable_;
 }
 
 void FuzzedHostResolver::RunLoopbackProbeJob() {
   SetHaveOnlyLoopbackAddresses(data_provider_->ConsumeBool());
 }
 
 }  // namespace net